summaryrefslogtreecommitdiffstats
path: root/third_party/rust/mp4parse/src
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /third_party/rust/mp4parse/src
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/mp4parse/src')
-rw-r--r--third_party/rust/mp4parse/src/boxes.rs241
-rw-r--r--third_party/rust/mp4parse/src/lib.rs6314
-rw-r--r--third_party/rust/mp4parse/src/macros.rs12
-rw-r--r--third_party/rust/mp4parse/src/tests.rs1366
-rw-r--r--third_party/rust/mp4parse/src/unstable.rs541
5 files changed, 8474 insertions, 0 deletions
diff --git a/third_party/rust/mp4parse/src/boxes.rs b/third_party/rust/mp4parse/src/boxes.rs
new file mode 100644
index 0000000000..7a9f22bed1
--- /dev/null
+++ b/third_party/rust/mp4parse/src/boxes.rs
@@ -0,0 +1,241 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+use std::fmt;
+
+// To ensure we don't use stdlib allocating types by accident
+#[allow(dead_code)]
+struct Vec;
+#[allow(dead_code)]
+struct Box;
+#[allow(dead_code)]
+struct HashMap;
+#[allow(dead_code)]
+struct String;
+
+macro_rules! box_database {
+ ($($(#[$attr:meta])* $boxenum:ident $boxtype:expr),*,) => {
+ #[derive(Clone, Copy, PartialEq, Eq)]
+ pub enum BoxType {
+ $($(#[$attr])* $boxenum),*,
+ UnknownBox(u32),
+ }
+
+ impl From<u32> for BoxType {
+ fn from(t: u32) -> BoxType {
+ use self::BoxType::*;
+ match t {
+ $($(#[$attr])* $boxtype => $boxenum),*,
+ _ => UnknownBox(t),
+ }
+ }
+ }
+
+ impl From<BoxType> for u32 {
+ fn from(b: BoxType) -> u32 {
+ use self::BoxType::*;
+ match b {
+ $($(#[$attr])* $boxenum => $boxtype),*,
+ UnknownBox(t) => t,
+ }
+ }
+ }
+
+ }
+}
+
+impl fmt::Debug for BoxType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let fourcc: FourCC = From::from(*self);
+ fourcc.fmt(f)
+ }
+}
+
+#[derive(Default, Eq, Hash, PartialEq, Clone)]
+pub struct FourCC {
+ pub value: [u8; 4],
+}
+
+impl From<u32> for FourCC {
+ fn from(number: u32) -> FourCC {
+ FourCC {
+ value: number.to_be_bytes(),
+ }
+ }
+}
+
+impl From<BoxType> for FourCC {
+ fn from(t: BoxType) -> FourCC {
+ let box_num: u32 = Into::into(t);
+ From::from(box_num)
+ }
+}
+
+impl From<[u8; 4]> for FourCC {
+ fn from(v: [u8; 4]) -> FourCC {
+ FourCC { value: v }
+ }
+}
+
+impl fmt::Debug for FourCC {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match std::str::from_utf8(&self.value) {
+ Ok(s) => f.write_str(s),
+ Err(_) => self.value.fmt(f),
+ }
+ }
+}
+
+impl fmt::Display for FourCC {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.write_str(std::str::from_utf8(&self.value).unwrap_or("null"))
+ }
+}
+
+impl PartialEq<&[u8; 4]> for FourCC {
+ fn eq(&self, other: &&[u8; 4]) -> bool {
+ self.value.eq(*other)
+ }
+}
+
+box_database!(
+ FileTypeBox 0x6674_7970, // "ftyp"
+ MediaDataBox 0x6d64_6174, // "mdat"
+ PrimaryItemBox 0x7069_746d, // "pitm"
+ ItemDataBox 0x6964_6174, // "idat"
+ ItemInfoBox 0x6969_6e66, // "iinf"
+ ItemInfoEntry 0x696e_6665, // "infe"
+ ItemLocationBox 0x696c_6f63, // "iloc"
+ MovieBox 0x6d6f_6f76, // "moov"
+ MovieHeaderBox 0x6d76_6864, // "mvhd"
+ TrackBox 0x7472_616b, // "trak"
+ TrackHeaderBox 0x746b_6864, // "tkhd"
+ TrackReferenceBox 0x7472_6566, // "tref"
+ AuxiliaryBox 0x6175_786C, // "auxl"
+ EditBox 0x6564_7473, // "edts"
+ MediaBox 0x6d64_6961, // "mdia"
+ EditListBox 0x656c_7374, // "elst"
+ MediaHeaderBox 0x6d64_6864, // "mdhd"
+ HandlerBox 0x6864_6c72, // "hdlr"
+ MediaInformationBox 0x6d69_6e66, // "minf"
+ ItemReferenceBox 0x6972_6566, // "iref"
+ ItemPropertiesBox 0x6970_7270, // "iprp"
+ ItemPropertyContainerBox 0x6970_636f, // "ipco"
+ ItemPropertyAssociationBox 0x6970_6d61, // "ipma"
+ ColourInformationBox 0x636f_6c72, // "colr"
+ ImageSpatialExtentsProperty 0x6973_7065, // "ispe"
+ PixelAspectRatioBox 0x7061_7370, // "pasp"
+ PixelInformationBox 0x7069_7869, // "pixi"
+ AuxiliaryTypeProperty 0x6175_7843, // "auxC"
+ CleanApertureBox 0x636c_6170, // "clap"
+ ImageRotation 0x6972_6f74, // "irot"
+ ImageMirror 0x696d_6972, // "imir"
+ OperatingPointSelectorProperty 0x6131_6f70, // "a1op"
+ AV1LayeredImageIndexingProperty 0x6131_6c78, // "a1lx"
+ LayerSelectorProperty 0x6c73_656c, // "lsel"
+ SampleTableBox 0x7374_626c, // "stbl"
+ SampleDescriptionBox 0x7374_7364, // "stsd"
+ TimeToSampleBox 0x7374_7473, // "stts"
+ SampleToChunkBox 0x7374_7363, // "stsc"
+ SampleSizeBox 0x7374_737a, // "stsz"
+ ChunkOffsetBox 0x7374_636f, // "stco"
+ ChunkLargeOffsetBox 0x636f_3634, // "co64"
+ SyncSampleBox 0x7374_7373, // "stss"
+ AVCSampleEntry 0x6176_6331, // "avc1"
+ AVC3SampleEntry 0x6176_6333, // "avc3" - Need to check official name in spec.
+ AVCConfigurationBox 0x6176_6343, // "avcC"
+ H263SampleEntry 0x7332_3633, // "s263"
+ H263SpecificBox 0x6432_3633, // "d263"
+ HEV1SampleEntry 0x6865_7631, // "hev1"
+ HVC1SampleEntry 0x6876_6331, // "hvc1"
+ HEVCConfigurationBox 0x6876_6343, // "hvcC"
+ MP4AudioSampleEntry 0x6d70_3461, // "mp4a"
+ MP4VideoSampleEntry 0x6d70_3476, // "mp4v"
+ #[cfg(feature = "3gpp")]
+ AMRNBSampleEntry 0x7361_6d72, // "samr" - AMR narrow-band
+ #[cfg(feature = "3gpp")]
+ AMRWBSampleEntry 0x7361_7762, // "sawb" - AMR wide-band
+ #[cfg(feature = "3gpp")]
+ AMRSpecificBox 0x6461_6d72, // "damr"
+ ESDBox 0x6573_6473, // "esds"
+ VP8SampleEntry 0x7670_3038, // "vp08"
+ VP9SampleEntry 0x7670_3039, // "vp09"
+ VPCodecConfigurationBox 0x7670_6343, // "vpcC"
+ AV1SampleEntry 0x6176_3031, // "av01"
+ AV1CodecConfigurationBox 0x6176_3143, // "av1C"
+ FLACSampleEntry 0x664c_6143, // "fLaC"
+ FLACSpecificBox 0x6466_4c61, // "dfLa"
+ OpusSampleEntry 0x4f70_7573, // "Opus"
+ OpusSpecificBox 0x644f_7073, // "dOps"
+ ProtectedVisualSampleEntry 0x656e_6376, // "encv" - Need to check official name in spec.
+ ProtectedAudioSampleEntry 0x656e_6361, // "enca" - Need to check official name in spec.
+ MovieExtendsBox 0x6d76_6578, // "mvex"
+ MovieExtendsHeaderBox 0x6d65_6864, // "mehd"
+ QTWaveAtom 0x7761_7665, // "wave" - quicktime atom
+ ProtectionSystemSpecificHeaderBox 0x7073_7368, // "pssh"
+ SchemeInformationBox 0x7363_6869, // "schi"
+ TrackEncryptionBox 0x7465_6e63, // "tenc"
+ ProtectionSchemeInfoBox 0x7369_6e66, // "sinf"
+ OriginalFormatBox 0x6672_6d61, // "frma"
+ SchemeTypeBox 0x7363_686d, // "schm"
+ MP3AudioSampleEntry 0x2e6d_7033, // ".mp3" - from F4V.
+ CompositionOffsetBox 0x6374_7473, // "ctts"
+ LPCMAudioSampleEntry 0x6c70_636d, // "lpcm" - quicktime atom
+ ALACSpecificBox 0x616c_6163, // "alac" - Also used by ALACSampleEntry
+ UuidBox 0x7575_6964, // "uuid"
+ MetadataBox 0x6d65_7461, // "meta"
+ MetadataHeaderBox 0x6d68_6472, // "mhdr"
+ MetadataItemKeysBox 0x6b65_7973, // "keys"
+ MetadataItemListEntry 0x696c_7374, // "ilst"
+ MetadataItemDataEntry 0x6461_7461, // "data"
+ MetadataItemNameBox 0x6e61_6d65, // "name"
+ #[cfg(feature = "meta-xml")]
+ MetadataXMLBox 0x786d_6c20, // "xml "
+ #[cfg(feature = "meta-xml")]
+ MetadataBXMLBox 0x6278_6d6c, // "bxml"
+ UserdataBox 0x7564_7461, // "udta"
+ AlbumEntry 0xa961_6c62, // "©alb"
+ ArtistEntry 0xa941_5254, // "©ART"
+ ArtistLowercaseEntry 0xa961_7274, // "©art"
+ AlbumArtistEntry 0x6141_5254, // "aART"
+ CommentEntry 0xa963_6d74, // "©cmt"
+ DateEntry 0xa964_6179, // "©day"
+ TitleEntry 0xa96e_616d, // "©nam"
+ CustomGenreEntry 0xa967_656e, // "©gen"
+ StandardGenreEntry 0x676e_7265, // "gnre"
+ TrackNumberEntry 0x7472_6b6e, // "trkn"
+ DiskNumberEntry 0x6469_736b, // "disk"
+ ComposerEntry 0xa977_7274, // "©wrt"
+ EncoderEntry 0xa974_6f6f, // "©too"
+ EncodedByEntry 0xa965_6e63, // "©enc"
+ TempoEntry 0x746d_706f, // "tmpo"
+ CopyrightEntry 0x6370_7274, // "cprt"
+ CompilationEntry 0x6370_696c, // "cpil"
+ CoverArtEntry 0x636f_7672, // "covr"
+ AdvisoryEntry 0x7274_6e67, // "rtng"
+ RatingEntry 0x7261_7465, // "rate"
+ GroupingEntry 0xa967_7270, // "©grp"
+ MediaTypeEntry 0x7374_696b, // "stik"
+ PodcastEntry 0x7063_7374, // "pcst"
+ CategoryEntry 0x6361_7467, // "catg"
+ KeywordEntry 0x6b65_7977, // "keyw"
+ PodcastUrlEntry 0x7075_726c, // "purl"
+ PodcastGuidEntry 0x6567_6964, // "egid"
+ DescriptionEntry 0x6465_7363, // "desc"
+ LongDescriptionEntry 0x6c64_6573, // "ldes"
+ LyricsEntry 0xa96c_7972, // "©lyr"
+ TVNetworkNameEntry 0x7476_6e6e, // "tvnn"
+ TVShowNameEntry 0x7476_7368, // "tvsh"
+ TVEpisodeNameEntry 0x7476_656e, // "tven"
+ TVSeasonNumberEntry 0x7476_736e, // "tvsn"
+ TVEpisodeNumberEntry 0x7476_6573, // "tves"
+ PurchaseDateEntry 0x7075_7264, // "purd"
+ GaplessPlaybackEntry 0x7067_6170, // "pgap"
+ OwnerEntry 0x6f77_6e72, // "ownr"
+ HDVideoEntry 0x6864_7664, // "hdvd"
+ SortNameEntry 0x736f_6e6d, // "sonm"
+ SortAlbumEntry 0x736f_616c, // "soal"
+ SortArtistEntry 0x736f_6172, // "soar"
+ SortAlbumArtistEntry 0x736f_6161, // "soaa"
+ SortComposerEntry 0x736f_636f, // "soco"
+);
diff --git a/third_party/rust/mp4parse/src/lib.rs b/third_party/rust/mp4parse/src/lib.rs
new file mode 100644
index 0000000000..ca110f6041
--- /dev/null
+++ b/third_party/rust/mp4parse/src/lib.rs
@@ -0,0 +1,6314 @@
+//! Module for parsing ISO Base Media Format aka video/mp4 streams.
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// `clippy::upper_case_acronyms` is a nightly-only lint as of 2021-03-15, so we
+// allow `clippy::unknown_clippy_lints` to ignore it on stable - but
+// `clippy::unknown_clippy_lints` has been renamed in nightly, so we need to
+// allow `renamed_and_removed_lints` to ignore a warning for that.
+#![allow(renamed_and_removed_lints)]
+#![allow(clippy::unknown_clippy_lints)]
+#![allow(clippy::upper_case_acronyms)]
+
+#[macro_use]
+extern crate log;
+
+extern crate bitreader;
+extern crate byteorder;
+extern crate fallible_collections;
+extern crate num_traits;
+use bitreader::{BitReader, ReadInto};
+use byteorder::{ReadBytesExt, WriteBytesExt};
+
+use fallible_collections::TryRead;
+use fallible_collections::TryReserveError;
+
+use num_traits::Num;
+use std::convert::{TryFrom, TryInto as _};
+use std::fmt;
+use std::io::Cursor;
+use std::io::{Read, Take};
+
+#[macro_use]
+mod macros;
+
+mod boxes;
+use crate::boxes::{BoxType, FourCC};
+
+// Unit tests.
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "unstable-api")]
+pub mod unstable;
+
+/// The HEIF image and image collection brand
+/// The 'mif1' brand indicates structural requirements on files
+/// See HEIF (ISO 23008-12:2017) § 10.2.1
+pub const MIF1_BRAND: FourCC = FourCC { value: *b"mif1" };
+
+/// The HEIF image sequence brand
+/// The 'msf1' brand indicates structural requirements on files
+/// See HEIF (ISO 23008-12:2017) § 10.3.1
+pub const MSF1_BRAND: FourCC = FourCC { value: *b"msf1" };
+
+/// The brand to identify AV1 image items
+/// The 'avif' brand indicates structural requirements on files
+/// See <https://aomediacodec.github.io/av1-avif/#image-and-image-collection-brand>
+pub const AVIF_BRAND: FourCC = FourCC { value: *b"avif" };
+
+/// The brand to identify AVIF image sequences
+/// The 'avis' brand indicates structural requirements on files
+/// See <https://aomediacodec.github.io/av1-avif/#image-and-image-collection-brand>
+pub const AVIS_BRAND: FourCC = FourCC { value: *b"avis" };
+
+/// A trait to indicate a type can be infallibly converted to `u64`.
+/// This should only be implemented for infallible conversions, so only unsigned types are valid.
+trait ToU64 {
+ fn to_u64(self) -> u64;
+}
+
+/// Statically verify that the platform `usize` can fit within a `u64`.
+/// If the size won't fit on the given platform, this will fail at compile time, but if a type
+/// which can fail `TryInto<usize>` is used, it may panic.
+impl ToU64 for usize {
+ fn to_u64(self) -> u64 {
+ static_assertions::const_assert!(
+ std::mem::size_of::<usize>() <= std::mem::size_of::<u64>()
+ );
+ self.try_into().expect("usize -> u64 conversion failed")
+ }
+}
+
+/// A trait to indicate a type can be infallibly converted to `usize`.
+/// This should only be implemented for infallible conversions, so only unsigned types are valid.
+pub trait ToUsize {
+ fn to_usize(self) -> usize;
+}
+
+/// Statically verify that the given type can fit within a `usize`.
+/// If the size won't fit on the given platform, this will fail at compile time, but if a type
+/// which can fail `TryInto<usize>` is used, it may panic.
+macro_rules! impl_to_usize_from {
+ ( $from_type:ty ) => {
+ impl ToUsize for $from_type {
+ fn to_usize(self) -> usize {
+ static_assertions::const_assert!(
+ std::mem::size_of::<$from_type>() <= std::mem::size_of::<usize>()
+ );
+ self.try_into().expect(concat!(
+ stringify!($from_type),
+ " -> usize conversion failed"
+ ))
+ }
+ }
+ };
+}
+
+impl_to_usize_from!(u8);
+impl_to_usize_from!(u16);
+impl_to_usize_from!(u32);
+
+/// Indicate the current offset (i.e., bytes already read) in a reader
+trait Offset {
+ fn offset(&self) -> u64;
+}
+
+/// Wraps a reader to track the current offset
+struct OffsetReader<'a, T: 'a> {
+ reader: &'a mut T,
+ offset: u64,
+}
+
+impl<'a, T> OffsetReader<'a, T> {
+ fn new(reader: &'a mut T) -> Self {
+ Self { reader, offset: 0 }
+ }
+}
+
+impl<'a, T> Offset for OffsetReader<'a, T> {
+ fn offset(&self) -> u64 {
+ self.offset
+ }
+}
+
+impl<'a, T: Read> Read for OffsetReader<'a, T> {
+ fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+ let bytes_read = self.reader.read(buf)?;
+ trace!("Read {} bytes at offset {}", bytes_read, self.offset);
+ self.offset = self
+ .offset
+ .checked_add(bytes_read.to_u64())
+ .expect("total bytes read too large for offset type");
+ Ok(bytes_read)
+ }
+}
+
+pub type TryVec<T> = fallible_collections::TryVec<T>;
+pub type TryString = fallible_collections::TryVec<u8>;
+pub type TryHashMap<K, V> = fallible_collections::TryHashMap<K, V>;
+pub type TryBox<T> = fallible_collections::TryBox<T>;
+
+// To ensure we don't use stdlib allocating types by accident
+#[allow(dead_code)]
+struct Vec;
+#[allow(dead_code)]
+struct Box;
+#[allow(dead_code)]
+struct HashMap;
+#[allow(dead_code)]
+struct String;
+
+/// The return value to the C API
+/// Any detail that needs to be communicated to the caller must be encoded here
+/// since the [`Error`] type's associated data is part of the FFI.
+#[repr(C)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Status {
+ Ok = 0,
+ BadArg = 1,
+ Invalid = 2,
+ Unsupported = 3,
+ Eof = 4,
+ Io = 5,
+ Oom = 6,
+ A1lxEssential,
+ A1opNoEssential,
+ AlacBadMagicCookieSize,
+ AlacFlagsNonzero,
+ Av1cMissing,
+ BitReaderError,
+ BoxBadSize,
+ BoxBadWideSize,
+ CheckParserStateErr,
+ ColrBadQuantity,
+ ColrBadSize,
+ ColrBadType,
+ ColrReservedNonzero,
+ ConstructionMethod,
+ CttsBadSize,
+ CttsBadVersion,
+ DflaBadMetadataBlockSize,
+ DflaFlagsNonzero,
+ DflaMissingMetadata,
+ DflaStreamInfoBadSize,
+ DflaStreamInfoNotFirst,
+ DopsChannelMappingWriteErr,
+ DopsOpusHeadWriteErr,
+ ElstBadVersion,
+ EsdsBadAudioSampleEntry,
+ EsdsBadDescriptor,
+ EsdsDecSpecificIntoTagQuantity,
+ FtypBadSize,
+ FtypNotFirst,
+ HdlrNameNoNul,
+ HdlrNameNotUtf8,
+ HdlrNotFirst,
+ HdlrPredefinedNonzero,
+ HdlrReservedNonzero,
+ HdlrTypeNotPict,
+ HdlrUnsupportedVersion,
+ HdrlBadQuantity,
+ IdatBadQuantity,
+ IdatMissing,
+ IinfBadChild,
+ IinfBadQuantity,
+ IlocBadConstructionMethod,
+ IlocBadExtent,
+ IlocBadExtentCount,
+ IlocBadFieldSize,
+ IlocBadQuantity,
+ IlocBadSize,
+ IlocDuplicateItemId,
+ IlocNotFound,
+ IlocOffsetOverflow,
+ ImageItemType,
+ InfeFlagsNonzero,
+ InvalidUtf8,
+ IpcoIndexOverflow,
+ IpmaBadIndex,
+ IpmaBadItemOrder,
+ IpmaBadQuantity,
+ IpmaBadVersion,
+ IpmaDuplicateItemId,
+ IpmaFlagsNonzero,
+ IpmaIndexZeroNoEssential,
+ IpmaTooBig,
+ IpmaTooSmall,
+ IprpBadChild,
+ IprpBadQuantity,
+ IprpConflict,
+ IrefBadQuantity,
+ IrefRecursion,
+ IspeMissing,
+ ItemTypeMissing,
+ LselNoEssential,
+ MdhdBadTimescale,
+ MdhdBadVersion,
+ MehdBadVersion,
+ MetaBadQuantity,
+ MissingAvifOrAvisBrand,
+ MissingMif1Brand,
+ MoovBadQuantity,
+ MoovMissing,
+ MultipleAlpha,
+ MvhdBadTimescale,
+ MvhdBadVersion,
+ NoImage,
+ PitmBadQuantity,
+ PitmMissing,
+ PitmNotFound,
+ PixiBadChannelCount,
+ PixiMissing,
+ PsshSizeOverflow,
+ ReadBufErr,
+ SchiQuantity,
+ StsdBadAudioSampleEntry,
+ StsdBadVideoSampleEntry,
+ TkhdBadVersion,
+ TxformBeforeIspe,
+ TxformNoEssential,
+ TxformOrder,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Feature {
+ A1lx,
+ A1op,
+ Auxc,
+ Av1c,
+ Avis,
+ Clap,
+ Colr,
+ Grid,
+ Imir,
+ Ipro,
+ Irot,
+ Ispe,
+ Lsel,
+ Pasp,
+ Pixi,
+}
+
+impl Feature {
+ fn supported(self) -> bool {
+ match self {
+ Self::Auxc
+ | Self::Av1c
+ | Self::Avis
+ | Self::Colr
+ | Self::Imir
+ | Self::Irot
+ | Self::Ispe
+ | Self::Pasp
+ | Self::Pixi => true,
+ Self::A1lx | Self::A1op | Self::Clap | Self::Grid | Self::Ipro | Self::Lsel => false,
+ }
+ }
+}
+
+impl TryFrom<&ItemProperty> for Feature {
+ type Error = Error;
+
+ fn try_from(item_property: &ItemProperty) -> Result<Self, Self::Error> {
+ Ok(match item_property {
+ ItemProperty::AuxiliaryType(_) => Self::Auxc,
+ ItemProperty::AV1Config(_) => Self::Av1c,
+ ItemProperty::Channels(_) => Self::Pixi,
+ ItemProperty::CleanAperture => Self::Clap,
+ ItemProperty::Colour(_) => Self::Colr,
+ ItemProperty::ImageSpatialExtents(_) => Self::Ispe,
+ ItemProperty::LayeredImageIndexing => Self::A1lx,
+ ItemProperty::LayerSelection => Self::Lsel,
+ ItemProperty::Mirroring(_) => Self::Imir,
+ ItemProperty::OperatingPointSelector => Self::A1op,
+ ItemProperty::PixelAspectRatio(_) => Self::Pasp,
+ ItemProperty::Rotation(_) => Self::Irot,
+ item_property => {
+ error!("No known Feature variant for {:?}", item_property);
+ return Err(Error::Unsupported("missing Feature fox ItemProperty"));
+ }
+ })
+ }
+}
+
+/// A collection to indicate unsupported features that were encountered during
+/// parsing. Since the default behavior for many such features is to ignore
+/// them, this often not fatal and there may be several to report.
+#[derive(Debug, Default)]
+pub struct UnsupportedFeatures(u32);
+
+impl UnsupportedFeatures {
+ pub fn new() -> Self {
+ Self(0x0)
+ }
+
+ pub fn into_bitfield(&self) -> u32 {
+ self.0
+ }
+
+ fn feature_to_bitfield(feature: Feature) -> u32 {
+ let index = feature as usize;
+ assert!(
+ u8::BITS.to_usize() * std::mem::size_of::<Self>() > index,
+ "You're gonna need a bigger bitfield"
+ );
+ let bitfield = 1u32 << index;
+ assert_eq!(bitfield.count_ones(), 1);
+ bitfield
+ }
+
+ pub fn insert(&mut self, feature: Feature) {
+ warn!("Unsupported feature: {:?}", feature);
+ self.0 |= Self::feature_to_bitfield(feature);
+ }
+
+ pub fn contains(&self, feature: Feature) -> bool {
+ self.0 & Self::feature_to_bitfield(feature) != 0x0
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.0 == 0x0
+ }
+}
+
+impl<T> From<Status> for Result<T> {
+ /// A convenience method to enable shortcuts like
+ /// ```
+ /// # use mp4parse::{Result,Status};
+ /// # let _: Result<()> =
+ /// Status::MissingAvifOrAvisBrand.into();
+ /// ```
+ /// instead of
+ /// ```
+ /// # use mp4parse::{Error,Result,Status};
+ /// # let _: Result<()> =
+ /// Err(Error::from(Status::MissingAvifOrAvisBrand));
+ /// ```
+ /// Note that `Status::Ok` can't be supported this way and will panic.
+ fn from(parse_status: Status) -> Self {
+ match parse_status {
+ Status::Ok => panic!("Can't determine Ok(_) inner value from Status"),
+ err_status => Err(err_status.into()),
+ }
+ }
+}
+
+/// For convenience of creating an error for an unsupported feature which we
+/// want to communicate the specific feature back to the C API caller
+impl From<Status> for Error {
+ fn from(parse_status: Status) -> Self {
+ match parse_status {
+ Status::Ok
+ | Status::BadArg
+ | Status::Invalid
+ | Status::Unsupported
+ | Status::Eof
+ | Status::Io
+ | Status::Oom => {
+ panic!("Status -> Error is only for Status:InvalidData errors")
+ }
+ _ => Self::InvalidData(parse_status),
+ }
+ }
+}
+
+impl From<Status> for &str {
+ fn from(status: Status) -> Self {
+ match status {
+ Status::Ok
+ | Status::BadArg
+ | Status::Invalid
+ | Status::Unsupported
+ | Status::Eof
+ | Status::Io
+ | Status::Oom => {
+ panic!("Status -> Error is only for specific parsing errors")
+ }
+ Status::A1lxEssential => {
+ "AV1LayeredImageIndexingProperty (a1lx) shall not be marked as essential \
+ per https://aomediacodec.github.io/av1-avif/#layered-image-indexing-property-description"
+ }
+ Status::A1opNoEssential => {
+ "OperatingPointSelectorProperty (a1op) shall be marked as essential \
+ per https://aomediacodec.github.io/av1-avif/#operating-point-selector-property-description"
+ }
+ Status::AlacBadMagicCookieSize => {
+ "ALACSpecificBox magic cookie is the wrong size"
+ }
+ Status::AlacFlagsNonzero => {
+ "no-zero alac (ALAC) flags"
+ }
+ Status::Av1cMissing => {
+ "One AV1 Item Configuration Property (av1C) is mandatory for an \
+ image item of type 'av01' \
+ per AVIF specification § 2.2.1"
+ }
+ Status::BitReaderError => {
+ "Bitwise read failed"
+ }
+ Status::BoxBadSize => {
+ "malformed size"
+ }
+ Status::BoxBadWideSize => {
+ "malformed wide size"
+ }
+ Status::CheckParserStateErr => {
+ "unread box content or bad parser sync"
+ }
+ Status::ColrBadQuantity => {
+ "Each item shall have at most one property association with a
+ ColourInformationBox (colr) for a given value of colour_type \
+ per HEIF (ISO/IEC DIS 23008-12) § 6.5.5.1"
+ }
+ Status::ColrBadSize => {
+ "Unexpected size for colr box"
+ }
+ Status::ColrBadType => {
+ "Unsupported colour_type for ColourInformationBox"
+ }
+ Status::ColrReservedNonzero => {
+ "The 7 reserved bits at the end of the ColourInformationBox \
+ for colour_type == 'nclx' must be 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 12.1.5.2"
+ }
+ Status::ConstructionMethod => {
+ "construction_method shall be 0 (file) or 1 (idat) per MIAF (ISO 23000-22:2019) § 7.2.1.7"
+ }
+ Status::CttsBadSize => {
+ "insufficient data in 'ctts' box"
+ }
+ Status::CttsBadVersion => {
+ "unsupported version in 'ctts' box"
+ }
+ Status::DflaBadMetadataBlockSize => {
+ "FLACMetadataBlock larger than parent box"
+ }
+ Status::DflaFlagsNonzero => {
+ "no-zero dfLa (FLAC) flags"
+ }
+ Status::DflaMissingMetadata => {
+ "FLACSpecificBox missing metadata"
+ }
+ Status::DflaStreamInfoBadSize => {
+ "FLACSpecificBox STREAMINFO block is the wrong size"
+ }
+ Status::DflaStreamInfoNotFirst => {
+ "FLACSpecificBox must have STREAMINFO metadata first"
+ }
+ Status::DopsChannelMappingWriteErr => {
+ "Couldn't write channel mapping table data."
+ }
+ Status::DopsOpusHeadWriteErr => {
+ "Couldn't write OpusHead tag."
+ }
+ Status::ElstBadVersion => {
+ "unhandled elst version"
+ }
+ Status::EsdsBadAudioSampleEntry => {
+ "malformed audio sample entry"
+ }
+ Status::EsdsBadDescriptor => {
+ "Invalid descriptor."
+ }
+ Status::EsdsDecSpecificIntoTagQuantity => {
+ "There can be only one DecSpecificInfoTag descriptor"
+ }
+ Status::FtypBadSize => {
+ "invalid ftyp size"
+ }
+ Status::FtypNotFirst => {
+ "The FileTypeBox shall be placed as early as possible in the file \
+ per ISOBMFF (ISO 14496-12:2020) § 4.3.1"
+ }
+ Status::HdlrNameNoNul => {
+ "The HandlerBox 'name' field shall be null-terminated \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"
+ }
+ Status::HdlrNameNotUtf8 => {
+ "The HandlerBox 'name' field shall be valid utf8 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"
+ }
+ Status::HdlrNotFirst => {
+ "The HandlerBox shall be the first contained box within the MetaBox \
+ per MIAF (ISO 23000-22:2019) § 7.2.1.5"
+ }
+ Status::HdlrPredefinedNonzero => {
+ "The HandlerBox 'pre_defined' field shall be 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"
+ }
+ Status::HdlrReservedNonzero => {
+ "The HandlerBox 'reserved' fields shall be 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"
+ }
+ Status::HdlrTypeNotPict => {
+ "The HandlerBox handler_type must be 'pict' \
+ per MIAF (ISO 23000-22:2019) § 7.2.1.5"
+ }
+ Status::HdlrUnsupportedVersion => {
+ "The HandlerBox version shall be 0 (zero) \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.2"
+ }
+ Status::HdrlBadQuantity => {
+ "There shall be exactly one hdlr box \
+ per ISOBMFF (ISO 14496-12:2020) § 8.4.3.1"
+ }
+ Status::IdatBadQuantity => {
+ "There shall be zero or one idat boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.11"
+ }
+ Status::IdatMissing => {
+ "ItemLocationBox (iloc) construction_method indicates 1 (idat), \
+ but no idat box is present."
+ }
+ Status::IinfBadChild => {
+ "iinf box shall contain only infe boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.6.2"
+ }
+ Status::IinfBadQuantity => {
+ "There shall be zero or one iinf boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.6.1"
+ }
+ Status::IlocBadConstructionMethod => {
+ "construction_method is taken from the set 0, 1 or 2 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.3.3"
+ }
+ Status::IlocBadExtent => {
+ "extent_count != 1 requires explicit offset and length \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.3.3"
+ }
+ Status::IlocBadExtentCount => {
+ "extent_count must have a value 1 or greater \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.3.3"
+ }
+ Status::IlocBadFieldSize => {
+ "value must be in the set {0, 4, 8}"
+ }
+ Status::IlocBadQuantity => {
+ "There shall be zero or one iloc boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.3.1"
+ }
+ Status::IlocBadSize => {
+ "invalid iloc size"
+ }
+ Status::IlocDuplicateItemId => {
+ "duplicate item_ID in iloc"
+ }
+ Status::IlocNotFound => {
+ "ItemLocationBox (iloc) contains an extent not present in any mdat or idat box"
+ }
+ Status::IlocOffsetOverflow => {
+ "offset calculation overflow"
+ }
+ Status::ImageItemType => {
+ "Image item type is neither 'av01' nor 'grid'"
+ }
+ Status::InfeFlagsNonzero => {
+ "'infe' flags field shall be 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.6.2"
+ }
+ Status::InvalidUtf8 => {
+ "invalid utf8"
+ }
+ Status::IpcoIndexOverflow => {
+ "ipco index overflow"
+ }
+ Status::IpmaBadIndex => {
+ "Invalid property index in ipma"
+ }
+ Status::IpmaBadItemOrder => {
+ "Each ItemPropertyAssociation box shall be ordered by increasing item_ID"
+ }
+ Status::IpmaBadQuantity => {
+ "There shall be at most one ItemPropertyAssociationbox with a given pair of \
+ values of version and flags \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"
+ }
+ Status::IpmaBadVersion => {
+ "The ipma version 0 should be used unless 32-bit item_ID values are needed \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"
+ }
+ Status::IpmaDuplicateItemId => {
+ "There shall be at most one occurrence of a given item_ID, \
+ in the set of ItemPropertyAssociationBox boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"
+ }
+ Status::IpmaFlagsNonzero => {
+ "Unless there are more than 127 properties in the ItemPropertyContainerBox, \
+ flags should be equal to 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"
+ }
+ Status::IpmaIndexZeroNoEssential => {
+ "the essential indicator shall be 0 for property index 0 \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.3"
+ }
+ Status::IpmaTooBig => {
+ "ipma box exceeds maximum size for entry_count"
+ }
+ Status::IpmaTooSmall => {
+ "ipma box below minimum size for entry_count"
+ }
+ Status::IprpBadChild => {
+ "unexpected iprp child"
+ }
+ Status::IprpBadQuantity => {
+ "There shall be zero or one iprp boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.14.1"
+ }
+ Status::IprpConflict => {
+ "conflicting item property values"
+ }
+ Status::IrefBadQuantity => {
+ "There shall be zero or one iref boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.12.1"
+ }
+ Status::IrefRecursion => {
+ "from_item_id and to_item_id must be different"
+ }
+ Status::IspeMissing => {
+ "Missing 'ispe' property for image item, required \
+ per HEIF (ISO/IEC 23008-12:2017) § 6.5.3.1"
+ }
+ Status::ItemTypeMissing => {
+ "No ItemInfoEntry for item_ID"
+ }
+ Status::LselNoEssential => {
+ "LayerSelectorProperty (lsel) shall be marked as essential \
+ per HEIF (ISO/IEC 23008-12:2017) § 6.5.11.1"
+ }
+ Status::MdhdBadTimescale => {
+ "zero timescale in mdhd"
+ }
+ Status::MdhdBadVersion => {
+ "unhandled mdhd version"
+ }
+ Status::MehdBadVersion => {
+ "unhandled mehd version"
+ }
+ Status::MetaBadQuantity => {
+ "There should be zero or one meta boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.1.1"
+ }
+ Status::MissingAvifOrAvisBrand => {
+ "The file shall list 'avif' or 'avis' in the compatible_brands field
+ of the FileTypeBox \
+ per https://aomediacodec.github.io/av1-avif/#file-constraints"
+ }
+ Status::MissingMif1Brand => {
+ "The FileTypeBox should contain 'mif1' in the compatible_brands list \
+ per MIAF (ISO 23000-22:2019/Amd. 2:2021) § 7.2.1.2"
+ }
+ Status::MoovBadQuantity => {
+ "Multiple moov boxes found; \
+ files with avis or msf1 brands shall contain exactly one moov box \
+ per ISOBMFF (ISO 14496-12:2020) § 8.2.1.1"
+ }
+ Status::MoovMissing => {
+ "No moov box found; \
+ files with avis or msf1 brands shall contain exactly one moov box \
+ per ISOBMFF (ISO 14496-12:2020) § 8.2.1.1"
+ }
+ Status::MultipleAlpha => {
+ "multiple alpha planes"
+ }
+ Status::MvhdBadTimescale => {
+ "zero timescale in mvhd"
+ }
+ Status::MvhdBadVersion => {
+ "unhandled mvhd version"
+ }
+ Status::NoImage => "No primary image or image sequence found",
+ Status::PitmBadQuantity => {
+ "There shall be zero or one pitm boxes \
+ per ISOBMFF (ISO 14496-12:2020) § 8.11.4.1"
+ }
+ Status::PitmMissing => {
+ "Missing required PrimaryItemBox (pitm), required \
+ per HEIF (ISO/IEC 23008-12:2017) § 10.2.1"
+ }
+ Status::PitmNotFound => {
+ "PrimaryItemBox (pitm) referenced an item ID that was not present"
+ }
+ Status::PixiBadChannelCount => {
+ "invalid num_channels"
+ }
+ Status::PixiMissing => {
+ "The pixel information property shall be associated with every image \
+ that is displayable (not hidden) \
+ per MIAF (ISO/IEC 23000-22:2019) specification § 7.3.6.6"
+ }
+ Status::PsshSizeOverflow => {
+ "overflow in read_pssh"
+ }
+ Status::ReadBufErr => {
+ "failed buffer read"
+ }
+ Status::SchiQuantity => {
+ "tenc box should be only one at most in sinf box"
+ }
+ Status::StsdBadAudioSampleEntry => {
+ "malformed audio sample entry"
+ }
+ Status::StsdBadVideoSampleEntry => {
+ "malformed video sample entry"
+ }
+ Status::TkhdBadVersion => {
+ "unhandled tkhd version"
+ }
+ Status::TxformBeforeIspe => {
+ "Every image item shall be associated with one property of \
+ type ImageSpatialExtentsProperty (ispe), prior to the \
+ association of all transformative properties. \
+ per HEIF (ISO/IEC 23008-12:2017) § 6.5.3.1"
+ }
+ Status::TxformNoEssential => {
+ "All transformative properties associated with coded and \
+ derived images required or conditionally required by this \
+ document shall be marked as essential \
+ per MIAF (ISO 23000-22:2019) § 7.3.9"
+ }
+ Status::TxformOrder => {
+ "These properties, if used, shall be indicated to be applied \
+ in the following order: clean aperture first, then rotation, \
+ then mirror. \
+ per MIAF (ISO/IEC 23000-22:2019) § 7.3.6.7"
+ }
+ }
+ }
+}
+
+impl From<Error> for Status {
+ fn from(error: Error) -> Self {
+ match error {
+ Error::Unsupported(_) => Self::Unsupported,
+ Error::InvalidData(parse_status) => parse_status,
+ Error::UnexpectedEOF => Self::Eof,
+ Error::Io(_) => {
+ // Getting std::io::ErrorKind::UnexpectedEof is normal
+ // but our From trait implementation should have converted
+ // those to our Error::UnexpectedEOF variant.
+ Self::Io
+ }
+ Error::MoovMissing => Self::MoovMissing,
+ Error::OutOfMemory => Self::Oom,
+ }
+ }
+}
+
+impl From<Result<(), Status>> for Status {
+ fn from(result: Result<(), Status>) -> Self {
+ match result {
+ Ok(()) => Status::Ok,
+ Err(Status::Ok) => unreachable!(),
+ Err(e) => e,
+ }
+ }
+}
+
+impl<T> From<Result<T>> for Status {
+ fn from(result: Result<T>) -> Self {
+ match result {
+ Ok(_) => Status::Ok,
+ Err(e) => Status::from(e),
+ }
+ }
+}
+
+impl From<fallible_collections::TryReserveError> for Status {
+ fn from(_: fallible_collections::TryReserveError) -> Self {
+ Status::Oom
+ }
+}
+
+impl From<std::io::Error> for Status {
+ fn from(_: std::io::Error) -> Self {
+ Status::Io
+ }
+}
+
+/// Describes parser failures.
+///
+/// This enum wraps the standard `io::Error` type, unified with
+/// our own parser error states and those of crates we use.
+#[derive(Debug)]
+pub enum Error {
+ /// Parse error caused by corrupt or malformed data.
+ /// See the helper [`From<Status> for Error`](enum.Error.html#impl-From<Status>)
+ InvalidData(Status),
+ /// Parse error caused by limited parser support rather than invalid data.
+ Unsupported(&'static str),
+ /// Reflect `std::io::ErrorKind::UnexpectedEof` for short data.
+ UnexpectedEOF,
+ /// Propagate underlying errors from `std::io`.
+ Io(std::io::Error),
+ /// read_mp4 terminated without detecting a moov box.
+ MoovMissing,
+ /// Out of memory
+ OutOfMemory,
+}
+
+impl std::fmt::Display for Error {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{self:?}")
+ }
+}
+
+impl std::error::Error for Error {}
+
+impl From<bitreader::BitReaderError> for Error {
+ fn from(_: bitreader::BitReaderError) -> Error {
+ Status::BitReaderError.into()
+ }
+}
+
+impl From<std::io::Error> for Error {
+ fn from(err: std::io::Error) -> Error {
+ match err.kind() {
+ std::io::ErrorKind::UnexpectedEof => Error::UnexpectedEOF,
+ _ => Error::Io(err),
+ }
+ }
+}
+
+impl From<std::string::FromUtf8Error> for Error {
+ fn from(_: std::string::FromUtf8Error) -> Error {
+ Status::InvalidUtf8.into()
+ }
+}
+
+impl From<std::str::Utf8Error> for Error {
+ fn from(_: std::str::Utf8Error) -> Error {
+ Status::InvalidUtf8.into()
+ }
+}
+
+impl From<std::num::TryFromIntError> for Error {
+ fn from(_: std::num::TryFromIntError) -> Error {
+ Error::Unsupported("integer conversion failed")
+ }
+}
+
+impl From<Error> for std::io::Error {
+ fn from(err: Error) -> Self {
+ let kind = match err {
+ Error::UnexpectedEOF => std::io::ErrorKind::UnexpectedEof,
+ Error::Io(io_err) => return io_err,
+ _ => std::io::ErrorKind::Other,
+ };
+ Self::new(kind, err)
+ }
+}
+
+impl From<TryReserveError> for Error {
+ fn from(_: TryReserveError) -> Error {
+ Error::OutOfMemory
+ }
+}
+
+/// Result shorthand using our Error enum.
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// Basic ISO box structure.
+///
+/// mp4 files are a sequence of possibly-nested 'box' structures. Each box
+/// begins with a header describing the length of the box's data and a
+/// four-byte box type which identifies the type of the box. Together these
+/// are enough to interpret the contents of that section of the file.
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 4.2
+#[derive(Debug, Clone, Copy)]
+struct BoxHeader {
+ /// Box type.
+ name: BoxType,
+ /// Size of the box in bytes.
+ size: u64,
+ /// Offset to the start of the contained data (or header size).
+ offset: u64,
+ /// Uuid for extended type.
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ uuid: Option<[u8; 16]>,
+}
+
+impl BoxHeader {
+ const MIN_SIZE: u64 = 8; // 4-byte size + 4-byte type
+ const MIN_LARGE_SIZE: u64 = 16; // 4-byte size + 4-byte type + 16-byte size
+}
+
+/// File type box 'ftyp'.
+#[derive(Debug)]
+struct FileTypeBox {
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ major_brand: FourCC,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ minor_version: u32,
+ compatible_brands: TryVec<FourCC>,
+}
+
+impl FileTypeBox {
+ fn contains(&self, brand: &FourCC) -> bool {
+ self.compatible_brands.contains(brand) || self.major_brand == *brand
+ }
+}
+
+/// Movie header box 'mvhd'.
+#[derive(Debug)]
+struct MovieHeaderBox {
+ pub timescale: u32,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ duration: u64,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Matrix {
+ pub a: i32, // 16.16 fix point
+ pub b: i32, // 16.16 fix point
+ pub u: i32, // 2.30 fix point
+ pub c: i32, // 16.16 fix point
+ pub d: i32, // 16.16 fix point
+ pub v: i32, // 2.30 fix point
+ pub x: i32, // 16.16 fix point
+ pub y: i32, // 16.16 fix point
+ pub w: i32, // 2.30 fix point
+}
+
+/// Track header box 'tkhd'
+#[derive(Debug, Clone)]
+pub struct TrackHeaderBox {
+ track_id: u32,
+ pub disabled: bool,
+ pub duration: u64,
+ pub width: u32,
+ pub height: u32,
+ pub matrix: Matrix,
+}
+
+/// Edit list box 'elst'
+#[derive(Debug)]
+struct EditListBox {
+ looped: bool,
+ edits: TryVec<Edit>,
+}
+
+#[derive(Debug)]
+struct Edit {
+ segment_duration: u64,
+ media_time: i64,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ media_rate_integer: i16,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ media_rate_fraction: i16,
+}
+
+/// Media header box 'mdhd'
+#[derive(Debug)]
+struct MediaHeaderBox {
+ timescale: u32,
+ duration: u64,
+}
+
+// Chunk offset box 'stco' or 'co64'
+#[derive(Debug)]
+pub struct ChunkOffsetBox {
+ pub offsets: TryVec<u64>,
+}
+
+// Sync sample box 'stss'
+#[derive(Debug)]
+pub struct SyncSampleBox {
+ pub samples: TryVec<u32>,
+}
+
+// Sample to chunk box 'stsc'
+#[derive(Debug)]
+pub struct SampleToChunkBox {
+ pub samples: TryVec<SampleToChunk>,
+}
+
+#[derive(Debug)]
+pub struct SampleToChunk {
+ pub first_chunk: u32,
+ pub samples_per_chunk: u32,
+ pub sample_description_index: u32,
+}
+
+// Sample size box 'stsz'
+#[derive(Debug)]
+pub struct SampleSizeBox {
+ pub sample_size: u32,
+ pub sample_sizes: TryVec<u32>,
+}
+
+// Time to sample box 'stts'
+#[derive(Debug)]
+pub struct TimeToSampleBox {
+ pub samples: TryVec<Sample>,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct Sample {
+ pub sample_count: u32,
+ pub sample_delta: u32,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum TimeOffsetVersion {
+ Version0(u32),
+ Version1(i32),
+}
+
+#[derive(Debug, Clone)]
+pub struct TimeOffset {
+ pub sample_count: u32,
+ pub time_offset: TimeOffsetVersion,
+}
+
+#[derive(Debug)]
+pub struct CompositionOffsetBox {
+ pub samples: TryVec<TimeOffset>,
+}
+
+// Handler reference box 'hdlr'
+#[derive(Debug)]
+struct HandlerBox {
+ handler_type: FourCC,
+}
+
+// Sample description box 'stsd'
+#[derive(Debug)]
+pub struct SampleDescriptionBox {
+ pub descriptions: TryVec<SampleEntry>,
+}
+
+#[derive(Debug)]
+pub enum SampleEntry {
+ Audio(AudioSampleEntry),
+ Video(VideoSampleEntry),
+ Unknown,
+}
+
+#[derive(Debug)]
+pub struct TrackReferenceBox {
+ pub references: TryVec<TrackReferenceEntry>,
+}
+
+impl TrackReferenceBox {
+ pub fn has_auxl_reference(&self, track_id: u32) -> bool {
+ self.references.iter().any(|entry| match entry {
+ TrackReferenceEntry::Auxiliary(aux_entry) => aux_entry.track_ids.contains(&track_id),
+ })
+ }
+}
+
+#[derive(Debug)]
+pub enum TrackReferenceEntry {
+ Auxiliary(TrackReference),
+}
+
+#[derive(Debug)]
+pub struct TrackReference {
+ pub track_ids: TryVec<u32>,
+}
+
+/// An Elementary Stream Descriptor
+/// See MPEG-4 Systems (ISO 14496-1:2010) § 7.2.6.5
+#[allow(non_camel_case_types)]
+#[derive(Debug, Default)]
+pub struct ES_Descriptor {
+ pub audio_codec: CodecType,
+ pub audio_object_type: Option<u16>,
+ pub extended_audio_object_type: Option<u16>,
+ pub audio_sample_rate: Option<u32>,
+ pub audio_channel_count: Option<u16>,
+ #[cfg(feature = "mp4v")]
+ pub video_codec: CodecType,
+ pub codec_esds: TryVec<u8>,
+ pub decoder_specific_data: TryVec<u8>, // Data in DECODER_SPECIFIC_TAG
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug)]
+pub enum AudioCodecSpecific {
+ ES_Descriptor(ES_Descriptor),
+ FLACSpecificBox(FLACSpecificBox),
+ OpusSpecificBox(OpusSpecificBox),
+ ALACSpecificBox(ALACSpecificBox),
+ MP3,
+ LPCM,
+ #[cfg(feature = "3gpp")]
+ AMRSpecificBox(TryVec<u8>),
+}
+
+#[derive(Debug)]
+pub struct AudioSampleEntry {
+ pub codec_type: CodecType,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ data_reference_index: u16,
+ pub channelcount: u32,
+ pub samplesize: u16,
+ pub samplerate: f64,
+ pub codec_specific: AudioCodecSpecific,
+ pub protection_info: TryVec<ProtectionSchemeInfoBox>,
+}
+
+#[derive(Debug)]
+pub enum VideoCodecSpecific {
+ AVCConfig(TryVec<u8>),
+ VPxConfig(VPxConfigBox),
+ AV1Config(AV1ConfigBox),
+ ESDSConfig(TryVec<u8>),
+ H263Config(TryVec<u8>),
+ HEVCConfig(TryVec<u8>),
+}
+
+#[derive(Debug)]
+pub struct VideoSampleEntry {
+ pub codec_type: CodecType,
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ data_reference_index: u16,
+ pub width: u16,
+ pub height: u16,
+ pub codec_specific: VideoCodecSpecific,
+ pub protection_info: TryVec<ProtectionSchemeInfoBox>,
+}
+
+/// Represent a Video Partition Codec Configuration 'vpcC' box (aka vp9). The meaning of each
+/// field is covered in detail in "VP Codec ISO Media File Format Binding".
+#[derive(Debug)]
+pub struct VPxConfigBox {
+ /// An integer that specifies the VP codec profile.
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ profile: u8,
+ /// An integer that specifies a VP codec level all samples conform to the following table.
+ /// For a description of the various levels, please refer to the VP9 Bitstream Specification.
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ level: u8,
+ /// An integer that specifies the bit depth of the luma and color components. Valid values
+ /// are 8, 10, and 12.
+ pub bit_depth: u8,
+ /// Really an enum defined by the "Colour primaries" section of ISO 23091-2:2019 § 8.1.
+ pub colour_primaries: u8,
+ /// Really an enum defined by "VP Codec ISO Media File Format Binding".
+ pub chroma_subsampling: u8,
+ /// Really an enum defined by the "Transfer characteristics" section of ISO 23091-2:2019 § 8.2.
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ transfer_characteristics: u8,
+ /// Really an enum defined by the "Matrix coefficients" section of ISO 23091-2:2019 § 8.3.
+ /// Available in 'VP Codec ISO Media File Format' version 1 only.
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ matrix_coefficients: Option<u8>,
+ /// Indicates the black level and range of the luma and chroma signals. 0 = legal range
+ /// (e.g. 16-235 for 8 bit sample depth); 1 = full range (e.g. 0-255 for 8-bit sample depth).
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ video_full_range_flag: bool,
+ /// This is not used for VP8 and VP9 . Intended for binary codec initialization data.
+ pub codec_init: TryVec<u8>,
+}
+
+/// See [AV1-ISOBMFF § 2.3.3](https://aomediacodec.github.io/av1-isobmff/#av1codecconfigurationbox-syntax)
+#[derive(Debug)]
+pub struct AV1ConfigBox {
+ pub profile: u8,
+ pub level: u8,
+ pub tier: u8,
+ pub bit_depth: u8,
+ pub monochrome: bool,
+ pub chroma_subsampling_x: u8,
+ pub chroma_subsampling_y: u8,
+ pub chroma_sample_position: u8,
+ pub initial_presentation_delay_present: bool,
+ pub initial_presentation_delay_minus_one: u8,
+ // The raw config contained in the av1c box. Because some decoders accept this data as a binary
+ // blob, rather than as structured data, we store the blob here for convenience.
+ pub raw_config: TryVec<u8>,
+}
+
+impl AV1ConfigBox {
+ const CONFIG_OBUS_OFFSET: usize = 4;
+
+ pub fn config_obus(&self) -> &[u8] {
+ &self.raw_config[Self::CONFIG_OBUS_OFFSET..]
+ }
+}
+
+#[derive(Debug)]
+pub struct FLACMetadataBlock {
+ pub block_type: u8,
+ pub data: TryVec<u8>,
+}
+
+/// Represents a FLACSpecificBox 'dfLa'
+#[derive(Debug)]
+pub struct FLACSpecificBox {
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ version: u8,
+ pub blocks: TryVec<FLACMetadataBlock>,
+}
+
+#[derive(Debug)]
+struct ChannelMappingTable {
+ stream_count: u8,
+ coupled_count: u8,
+ channel_mapping: TryVec<u8>,
+}
+
+/// Represent an OpusSpecificBox 'dOps'
+#[derive(Debug)]
+pub struct OpusSpecificBox {
+ pub version: u8,
+ output_channel_count: u8,
+ pre_skip: u16,
+ input_sample_rate: u32,
+ output_gain: i16,
+ channel_mapping_family: u8,
+ channel_mapping_table: Option<ChannelMappingTable>,
+}
+
+/// Represent an ALACSpecificBox 'alac'
+#[derive(Debug)]
+pub struct ALACSpecificBox {
+ #[allow(dead_code)] // See https://github.com/mozilla/mp4parse-rust/issues/340
+ version: u8,
+ pub data: TryVec<u8>,
+}
+
+#[derive(Debug)]
+pub struct MovieExtendsBox {
+ pub fragment_duration: Option<MediaScaledTime>,
+}
+
+pub type ByteData = TryVec<u8>;
+
+#[derive(Debug, Default)]
+pub struct ProtectionSystemSpecificHeaderBox {
+ pub system_id: ByteData,
+ pub kid: TryVec<ByteData>,
+ pub data: ByteData,
+
+ // The entire pssh box (include header) required by Gecko.
+ pub box_content: ByteData,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct SchemeTypeBox {
+ pub scheme_type: FourCC,
+ pub scheme_version: u32,
+}
+
+#[derive(Debug, Default)]
+pub struct TrackEncryptionBox {
+ pub is_encrypted: u8,
+ pub iv_size: u8,
+ pub kid: TryVec<u8>,
+ // Members for pattern encryption schemes
+ pub crypt_byte_block_count: Option<u8>,
+ pub skip_byte_block_count: Option<u8>,
+ pub constant_iv: Option<TryVec<u8>>,
+ // End pattern encryption scheme members
+}
+
+#[derive(Debug, Default)]
+pub struct ProtectionSchemeInfoBox {
+ pub original_format: FourCC,
+ pub scheme_type: Option<SchemeTypeBox>,
+ pub tenc: Option<TrackEncryptionBox>,
+}
+
+/// Represents a userdata box 'udta'.
+/// Currently, only the metadata atom 'meta'
+/// is parsed.
+#[derive(Debug, Default)]
+pub struct UserdataBox {
+ pub meta: Option<MetadataBox>,
+}
+
+/// Represents possible contents of the
+/// ©gen or gnre atoms within a metadata box.
+/// 'udta.meta.ilst' may only have either a
+/// standard genre box 'gnre' or a custom
+/// genre box '©gen', but never both at once.
+#[derive(Debug, PartialEq)]
+pub enum Genre {
+ /// A standard ID3v1 numbered genre.
+ StandardGenre(u8),
+ /// Any custom genre string.
+ CustomGenre(TryString),
+}
+
+/// Represents the contents of a 'stik'
+/// atom that indicates content types within
+/// iTunes.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum MediaType {
+ /// Movie is stored as 0 in a 'stik' atom.
+ Movie, // 0
+ /// Normal is stored as 1 in a 'stik' atom.
+ Normal, // 1
+ /// AudioBook is stored as 2 in a 'stik' atom.
+ AudioBook, // 2
+ /// WhackedBookmark is stored as 5 in a 'stik' atom.
+ WhackedBookmark, // 5
+ /// MusicVideo is stored as 6 in a 'stik' atom.
+ MusicVideo, // 6
+ /// ShortFilm is stored as 9 in a 'stik' atom.
+ ShortFilm, // 9
+ /// TVShow is stored as 10 in a 'stik' atom.
+ TVShow, // 10
+ /// Booklet is stored as 11 in a 'stik' atom.
+ Booklet, // 11
+ /// An unknown 'stik' value.
+ Unknown(u8),
+}
+
+/// Represents the parental advisory rating on the track,
+/// stored within the 'rtng' atom.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum AdvisoryRating {
+ /// Clean is always stored as 2 in an 'rtng' atom.
+ Clean, // 2
+ /// A value of 0 in an 'rtng' atom indicates 'Inoffensive'
+ Inoffensive, // 0
+ /// Any non 2 or 0 value in 'rtng' indicates the track is explicit.
+ Explicit(u8),
+}
+
+/// Represents the contents of 'ilst' atoms within
+/// a metadata box 'meta', parsed as iTunes metadata using
+/// the conventional tags.
+#[derive(Debug, Default)]
+pub struct MetadataBox {
+ /// The album name, '©alb'
+ pub album: Option<TryString>,
+ /// The artist name '©art' or '©ART'
+ pub artist: Option<TryString>,
+ /// The album artist 'aART'
+ pub album_artist: Option<TryString>,
+ /// Track comments '©cmt'
+ pub comment: Option<TryString>,
+ /// The date or year field '©day'
+ ///
+ /// This is stored as an arbitrary string,
+ /// and may not necessarily be in a valid date
+ /// format.
+ pub year: Option<TryString>,
+ /// The track title '©nam'
+ pub title: Option<TryString>,
+ /// The track genre '©gen' or 'gnre'.
+ pub genre: Option<Genre>,
+ /// The track number 'trkn'.
+ pub track_number: Option<u8>,
+ /// The disc number 'disk'
+ pub disc_number: Option<u8>,
+ /// The total number of tracks on the disc,
+ /// stored in 'trkn'
+ pub total_tracks: Option<u8>,
+ /// The total number of discs in the album,
+ /// stored in 'disk'
+ pub total_discs: Option<u8>,
+ /// The composer of the track '©wrt'
+ pub composer: Option<TryString>,
+ /// The encoder used to create this track '©too'
+ pub encoder: Option<TryString>,
+ /// The encoded-by settingo this track '©enc'
+ pub encoded_by: Option<TryString>,
+ /// The tempo or BPM of the track 'tmpo'
+ pub beats_per_minute: Option<u8>,
+ /// Copyright information of the track 'cprt'
+ pub copyright: Option<TryString>,
+ /// Whether or not this track is part of a compilation 'cpil'
+ pub compilation: Option<bool>,
+ /// The advisory rating of this track 'rtng'
+ pub advisory: Option<AdvisoryRating>,
+ /// The personal rating of this track, 'rate'.
+ ///
+ /// This is stored in the box as string data, but
+ /// the format is an integer percentage from 0 - 100,
+ /// where 100 is displayed as 5 stars out of 5.
+ pub rating: Option<TryString>,
+ /// The grouping this track belongs to '©grp'
+ pub grouping: Option<TryString>,
+ /// The media type of this track 'stik'
+ pub media_type: Option<MediaType>, // stik
+ /// Whether or not this track is a podcast 'pcst'
+ pub podcast: Option<bool>,
+ /// The category of ths track 'catg'
+ pub category: Option<TryString>,
+ /// The podcast keyword 'keyw'
+ pub keyword: Option<TryString>,
+ /// The podcast url 'purl'
+ pub podcast_url: Option<TryString>,
+ /// The podcast episode GUID 'egid'
+ pub podcast_guid: Option<TryString>,
+ /// The description of the track 'desc'
+ pub description: Option<TryString>,
+ /// The long description of the track 'ldes'.
+ ///
+ /// Unlike other string fields, the long description field
+ /// can be longer than 256 characters.
+ pub long_description: Option<TryString>,
+ /// The lyrics of the track '©lyr'.
+ ///
+ /// Unlike other string fields, the lyrics field
+ /// can be longer than 256 characters.
+ pub lyrics: Option<TryString>,
+ /// The name of the TV network this track aired on 'tvnn'.
+ pub tv_network_name: Option<TryString>,
+ /// The name of the TV Show for this track 'tvsh'.
+ pub tv_show_name: Option<TryString>,
+ /// The name of the TV Episode for this track 'tven'.
+ pub tv_episode_name: Option<TryString>,
+ /// The number of the TV Episode for this track 'tves'.
+ pub tv_episode_number: Option<u8>,
+ /// The season of the TV Episode of this track 'tvsn'.
+ pub tv_season: Option<u8>,
+ /// The date this track was purchased 'purd'.
+ pub purchase_date: Option<TryString>,
+ /// Whether or not this track supports gapless playback 'pgap'
+ pub gapless_playback: Option<bool>,
+ /// Any cover artwork attached to this track 'covr'
+ ///
+ /// 'covr' is unique in that it may contain multiple 'data' sub-entries,
+ /// each an image file. Here, each subentry's raw binary data is exposed,
+ /// which may contain image data in JPEG or PNG format.
+ pub cover_art: Option<TryVec<TryVec<u8>>>,
+ /// The owner of the track 'ownr'
+ pub owner: Option<TryString>,
+ /// Whether or not this track is HD Video 'hdvd'
+ pub hd_video: Option<bool>,
+ /// The name of the track to sort by 'sonm'
+ pub sort_name: Option<TryString>,
+ /// The name of the album to sort by 'soal'
+ pub sort_album: Option<TryString>,
+ /// The name of the artist to sort by 'soar'
+ pub sort_artist: Option<TryString>,
+ /// The name of the album artist to sort by 'soaa'
+ pub sort_album_artist: Option<TryString>,
+ /// The name of the composer to sort by 'soco'
+ pub sort_composer: Option<TryString>,
+ /// Metadata
+ #[cfg(feature = "meta-xml")]
+ pub xml: Option<XmlBox>,
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.2.1
+#[cfg(feature = "meta-xml")]
+#[derive(Debug)]
+pub enum XmlBox {
+ /// XML metadata
+ StringXmlBox(TryString),
+ /// Binary XML metadata
+ BinaryXmlBox(TryVec<u8>),
+}
+
+/// Internal data structures.
+#[derive(Debug, Default)]
+pub struct MediaContext {
+ pub timescale: Option<MediaTimeScale>,
+ /// Tracks found in the file.
+ pub tracks: TryVec<Track>,
+ pub mvex: Option<MovieExtendsBox>,
+ pub psshs: TryVec<ProtectionSystemSpecificHeaderBox>,
+ pub userdata: Option<Result<UserdataBox>>,
+ #[cfg(feature = "meta-xml")]
+ pub metadata: Option<Result<MetadataBox>>,
+}
+
+/// An ISOBMFF item as described by an iloc box. For the sake of avoiding copies,
+/// this can either be represented by the `Location` variant, which indicates
+/// where the data exists within a `DataBox` stored separately, or the `Data`
+/// variant which owns the data. Unfortunately, it's not simple to represent
+/// this as a [`std::borrow::Cow`], or other reference-based type, because
+/// multiple instances may references different parts of the same [`DataBox`]
+/// and we want to avoid the copy that splitting the storage would entail.
+enum IsobmffItem {
+ MdatLocation(Extent),
+ IdatLocation(Extent),
+ Data(TryVec<u8>),
+}
+
+impl fmt::Debug for IsobmffItem {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match &self {
+ IsobmffItem::MdatLocation(extent) | IsobmffItem::IdatLocation(extent) => f
+ .debug_struct("IsobmffItem::Location")
+ .field("0", &format_args!("{extent:?}"))
+ .finish(),
+ IsobmffItem::Data(data) => f
+ .debug_struct("IsobmffItem::Data")
+ .field("0", &format_args!("{} bytes", data.len()))
+ .finish(),
+ }
+ }
+}
+
+#[derive(Debug)]
+struct AvifItem {
+ /// The `item_ID` from ISOBMFF (ISO 14496-12:2020) § 8.11.3
+ ///
+ /// See [`read_iloc`]
+ id: ItemId,
+
+ /// AV1 Image Item per <https://aomediacodec.github.io/av1-avif/#image-item>
+ image_data: IsobmffItem,
+}
+
+impl AvifItem {
+ fn with_inline_data(id: ItemId) -> Self {
+ Self {
+ id,
+ image_data: IsobmffItem::Data(TryVec::new()),
+ }
+ }
+}
+
+#[derive(Default, Debug)]
+pub struct AvifContext {
+ /// Level of deviation from the specification before failing the parse
+ strictness: ParseStrictness,
+ /// Storage elements which can be located anywhere within the "file" identified by
+ /// [`BoxType::ItemLocationBox`]es using [`ConstructionMethod::File`].
+ /// Referred to by the [`IsobmffItem`]`::*Location` variants of the `AvifItem`s in this struct
+ media_storage: TryVec<DataBox>,
+ /// Similar to `media_storage`, but for a single optional chunk of storage within the
+ /// MetaBox itentified by [`BoxType::ItemLocationBox`]es using [`ConstructionMethod::Idat`].
+ item_data_box: Option<DataBox>,
+ /// The item indicated by the `pitm` box, See ISOBMFF (ISO 14496-12:2020) § 8.11.4
+ /// May be `None` in the pure image sequence case.
+ primary_item: Option<AvifItem>,
+ /// Associated alpha channel for the primary item, if any
+ alpha_item: Option<AvifItem>,
+ /// If true, divide RGB values by the alpha value.
+ /// See `prem` in MIAF (ISO 23000-22:2019) § 7.3.5.2
+ pub premultiplied_alpha: bool,
+ /// All properties associated with `primary_item` or `alpha_item`
+ item_properties: ItemPropertiesBox,
+ /// Should probably only ever be [`AVIF_BRAND`] or [`AVIS_BRAND`], but other values
+ /// are legal as long as one of the two is the `compatible_brand` list.
+ pub major_brand: FourCC,
+ /// Information on the sequence contained in the image, or None if not present
+ pub sequence: Option<MediaContext>,
+ /// A collection of unsupported features encountered during the parse
+ pub unsupported_features: UnsupportedFeatures,
+}
+
+impl AvifContext {
+ pub fn primary_item_is_present(&self) -> bool {
+ self.primary_item.is_some()
+ }
+
+ pub fn primary_item_coded_data(&self) -> Option<&[u8]> {
+ self.primary_item
+ .as_ref()
+ .map(|item| self.item_as_slice(item))
+ }
+
+ pub fn primary_item_bits_per_channel(&self) -> Option<Result<&[u8]>> {
+ self.primary_item
+ .as_ref()
+ .map(|item| self.image_bits_per_channel(item.id))
+ }
+
+ pub fn alpha_item_is_present(&self) -> bool {
+ self.alpha_item.is_some()
+ }
+
+ pub fn alpha_item_coded_data(&self) -> Option<&[u8]> {
+ self.alpha_item
+ .as_ref()
+ .map(|item| self.item_as_slice(item))
+ }
+
+ pub fn alpha_item_bits_per_channel(&self) -> Option<Result<&[u8]>> {
+ self.alpha_item
+ .as_ref()
+ .map(|item| self.image_bits_per_channel(item.id))
+ }
+
+ fn image_bits_per_channel(&self, item_id: ItemId) -> Result<&[u8]> {
+ match self
+ .item_properties
+ .get(item_id, BoxType::PixelInformationBox)?
+ {
+ Some(ItemProperty::Channels(pixi)) => Ok(pixi.bits_per_channel.as_slice()),
+ Some(other_property) => panic!("property key mismatch: {:?}", other_property),
+ None => Ok(&[]),
+ }
+ }
+
+ pub fn spatial_extents_ptr(&self) -> Result<*const ImageSpatialExtentsProperty> {
+ if let Some(primary_item) = &self.primary_item {
+ match self
+ .item_properties
+ .get(primary_item.id, BoxType::ImageSpatialExtentsProperty)?
+ {
+ Some(ItemProperty::ImageSpatialExtents(ispe)) => Ok(ispe),
+ Some(other_property) => panic!("property key mismatch: {:?}", other_property),
+ None => {
+ fail_with_status_if(
+ self.strictness != ParseStrictness::Permissive,
+ Status::IspeMissing,
+ )?;
+ Ok(std::ptr::null())
+ }
+ }
+ } else {
+ Ok(std::ptr::null())
+ }
+ }
+
+ /// Returns None if there is no primary item or it has no associated NCLX colour boxes.
+ pub fn nclx_colour_information_ptr(&self) -> Option<Result<*const NclxColourInformation>> {
+ if let Some(primary_item) = &self.primary_item {
+ match self.item_properties.get_multiple(primary_item.id, |prop| {
+ matches!(prop, ItemProperty::Colour(ColourInformation::Nclx(_)))
+ }) {
+ Ok(nclx_colr_boxes) => match *nclx_colr_boxes.as_slice() {
+ [] => None,
+ [ItemProperty::Colour(ColourInformation::Nclx(nclx)), ..] => {
+ if nclx_colr_boxes.len() > 1 {
+ warn!("Multiple nclx colr boxes, using first");
+ }
+ Some(Ok(nclx))
+ }
+ _ => unreachable!("Expect only ColourInformation::Nclx(_) matches"),
+ },
+ Err(e) => Some(Err(e)),
+ }
+ } else {
+ None
+ }
+ }
+
+ /// Returns None if there is no primary item or it has no associated ICC colour boxes.
+ pub fn icc_colour_information(&self) -> Option<Result<&[u8]>> {
+ if let Some(primary_item) = &self.primary_item {
+ match self.item_properties.get_multiple(primary_item.id, |prop| {
+ matches!(prop, ItemProperty::Colour(ColourInformation::Icc(_, _)))
+ }) {
+ Ok(icc_colr_boxes) => match *icc_colr_boxes.as_slice() {
+ [] => None,
+ [ItemProperty::Colour(ColourInformation::Icc(icc, _)), ..] => {
+ if icc_colr_boxes.len() > 1 {
+ warn!("Multiple ICC profiles in colr boxes, using first");
+ }
+ Some(Ok(icc.bytes.as_slice()))
+ }
+ _ => unreachable!("Expect only ColourInformation::Icc(_) matches"),
+ },
+ Err(e) => Some(Err(e)),
+ }
+ } else {
+ None
+ }
+ }
+
+ pub fn image_rotation(&self) -> Result<ImageRotation> {
+ if let Some(primary_item) = &self.primary_item {
+ match self
+ .item_properties
+ .get(primary_item.id, BoxType::ImageRotation)?
+ {
+ Some(ItemProperty::Rotation(irot)) => Ok(*irot),
+ Some(other_property) => panic!("property key mismatch: {:?}", other_property),
+ None => Ok(ImageRotation::D0),
+ }
+ } else {
+ Ok(ImageRotation::D0)
+ }
+ }
+
+ pub fn image_mirror_ptr(&self) -> Result<*const ImageMirror> {
+ if let Some(primary_item) = &self.primary_item {
+ match self
+ .item_properties
+ .get(primary_item.id, BoxType::ImageMirror)?
+ {
+ Some(ItemProperty::Mirroring(imir)) => Ok(imir),
+ Some(other_property) => panic!("property key mismatch: {:?}", other_property),
+ None => Ok(std::ptr::null()),
+ }
+ } else {
+ Ok(std::ptr::null())
+ }
+ }
+
+ pub fn pixel_aspect_ratio_ptr(&self) -> Result<*const PixelAspectRatio> {
+ if let Some(primary_item) = &self.primary_item {
+ match self
+ .item_properties
+ .get(primary_item.id, BoxType::PixelAspectRatioBox)?
+ {
+ Some(ItemProperty::PixelAspectRatio(pasp)) => Ok(pasp),
+ Some(other_property) => panic!("property key mismatch: {:?}", other_property),
+ None => Ok(std::ptr::null()),
+ }
+ } else {
+ Ok(std::ptr::null())
+ }
+ }
+
+ /// A helper for the various `AvifItem`s to expose a reference to the
+ /// underlying data while avoiding copies.
+ fn item_as_slice<'a>(&'a self, item: &'a AvifItem) -> &'a [u8] {
+ match &item.image_data {
+ IsobmffItem::MdatLocation(extent) => {
+ for mdat in &self.media_storage {
+ if let Some(slice) = mdat.get(extent) {
+ return slice;
+ }
+ }
+ unreachable!(
+ "IsobmffItem::MdatLocation requires the location exists in AvifContext::media_storage"
+ );
+ }
+ IsobmffItem::IdatLocation(extent) => {
+ self.item_data_box
+ .as_ref()
+ .and_then(|idat| idat.get(extent))
+ .unwrap_or_else(|| unreachable!("IsobmffItem::IdatLocation equires the location exists in AvifContext::item_data_box"))
+ }
+ IsobmffItem::Data(data) => data.as_slice(),
+ }
+ }
+}
+
+struct AvifMeta {
+ item_references: TryVec<SingleItemTypeReferenceBox>,
+ item_properties: ItemPropertiesBox,
+ /// Required for AvifImageType::Primary, but optional otherwise
+ /// See HEIF (ISO/IEC 23008-12:2017) § 7.1, 10.2.1
+ primary_item_id: Option<ItemId>,
+ item_infos: TryVec<ItemInfoEntry>,
+ iloc_items: TryHashMap<ItemId, ItemLocationBoxItem>,
+ item_data_box: Option<DataBox>,
+}
+
+#[derive(Debug)]
+enum DataBoxMetadata {
+ Idat,
+ Mdat {
+ /// Offset of `data` from the beginning of the "file". See ConstructionMethod::File.
+ /// Note: the file may not be an actual file, read_avif supports any `&mut impl Read`
+ /// source for input. However we try to match the terminology used in the spec.
+ file_offset: u64,
+ },
+}
+
+/// Represents either an Item Data Box (ISOBMFF (ISO 14496-12:2020) § 8.11.11)
+/// Or a Media Data Box (ISOBMFF (ISO 14496-12:2020) § 8.1.1)
+struct DataBox {
+ metadata: DataBoxMetadata,
+ data: TryVec<u8>,
+}
+
+impl fmt::Debug for DataBox {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("DataBox")
+ .field("metadata", &self.metadata)
+ .field("data", &format_args!("{} bytes", self.data.len()))
+ .finish()
+ }
+}
+
+fn u64_to_usize_logged(x: u64) -> Option<usize> {
+ match x.try_into() {
+ Ok(x) => Some(x),
+ Err(e) => {
+ error!("{:?} converting {:?}", e, x);
+ None
+ }
+ }
+}
+
+impl DataBox {
+ fn from_mdat(file_offset: u64, data: TryVec<u8>) -> Self {
+ Self {
+ metadata: DataBoxMetadata::Mdat { file_offset },
+ data,
+ }
+ }
+
+ fn from_idat(data: TryVec<u8>) -> Self {
+ Self {
+ metadata: DataBoxMetadata::Idat,
+ data,
+ }
+ }
+
+ fn data(&self) -> &[u8] {
+ &self.data
+ }
+
+ /// Convert an absolute offset to an offset relative to the beginning of the
+ /// slice [`DataBox::data`] returns. Returns None if the offset would be
+ /// negative or if the offset would overflow a `usize`.
+ fn start(&self, offset: u64) -> Option<usize> {
+ match self.metadata {
+ DataBoxMetadata::Idat => u64_to_usize_logged(offset),
+ DataBoxMetadata::Mdat { file_offset } => {
+ let start = offset.checked_sub(file_offset);
+ if start.is_none() {
+ error!("Overflow subtracting {} + {}", offset, file_offset);
+ }
+ u64_to_usize_logged(start?)
+ }
+ }
+ }
+
+ /// Returns an appropriate variant of [`IsobmffItem`] to describe the extent
+ /// referencing data within this type of box.
+ fn location(&self, extent: &Extent) -> IsobmffItem {
+ match self.metadata {
+ DataBoxMetadata::Idat => IsobmffItem::IdatLocation(extent.clone()),
+ DataBoxMetadata::Mdat { .. } => IsobmffItem::MdatLocation(extent.clone()),
+ }
+ }
+
+ /// Return a slice from the DataBox specified by the provided `extent`.
+ /// Returns `None` if the extent isn't fully contained by the DataBox or if
+ /// either the offset or length (if the extent is bounded) of the slice
+ /// would overflow a `usize`.
+ fn get<'a>(&'a self, extent: &'a Extent) -> Option<&'a [u8]> {
+ match extent {
+ Extent::WithLength { offset, len } => {
+ let start = self.start(*offset)?;
+ let end = start.checked_add(*len);
+ if end.is_none() {
+ error!("Overflow adding {} + {}", start, len);
+ }
+ self.data().get(start..end?)
+ }
+ Extent::ToEnd { offset } => {
+ let start = self.start(*offset)?;
+ self.data().get(start..)
+ }
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+struct PropertyIndex(u16);
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd)]
+struct ItemId(u32);
+
+impl ItemId {
+ fn read(src: &mut impl ReadBytesExt, version: u8) -> Result<ItemId> {
+ Ok(ItemId(if version == 0 {
+ be_u16(src)?.into()
+ } else {
+ be_u32(src)?
+ }))
+ }
+}
+
+/// Used for 'infe' boxes within 'iinf' boxes
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.6
+/// Only versions {2, 3} are supported
+#[derive(Debug)]
+struct ItemInfoEntry {
+ item_id: ItemId,
+ item_type: u32,
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.12
+#[derive(Debug)]
+struct SingleItemTypeReferenceBox {
+ item_type: FourCC,
+ from_item_id: ItemId,
+ to_item_id: ItemId,
+}
+
+/// Potential sizes (in bytes) of variable-sized fields of the 'iloc' box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.3
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum IlocFieldSize {
+ Zero,
+ Four,
+ Eight,
+}
+
+impl IlocFieldSize {
+ fn as_bits(&self) -> u8 {
+ match self {
+ IlocFieldSize::Zero => 0,
+ IlocFieldSize::Four => 32,
+ IlocFieldSize::Eight => 64,
+ }
+ }
+}
+
+impl TryFrom<u8> for IlocFieldSize {
+ type Error = Error;
+
+ fn try_from(value: u8) -> Result<Self> {
+ match value {
+ 0 => Ok(Self::Zero),
+ 4 => Ok(Self::Four),
+ 8 => Ok(Self::Eight),
+ _ => Status::IlocBadFieldSize.into(),
+ }
+ }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum IlocVersion {
+ Zero,
+ One,
+ Two,
+}
+
+impl TryFrom<u8> for IlocVersion {
+ type Error = Error;
+
+ fn try_from(value: u8) -> Result<Self> {
+ match value {
+ 0 => Ok(Self::Zero),
+ 1 => Ok(Self::One),
+ 2 => Ok(Self::Two),
+ _ => Err(Error::Unsupported("unsupported version in 'iloc' box")),
+ }
+ }
+}
+
+/// Used for 'iloc' boxes
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.3
+/// `base_offset` is omitted since it is integrated into the ranges in `extents`
+/// `data_reference_index` is omitted, since only 0 (i.e., this file) is supported
+#[derive(Debug)]
+struct ItemLocationBoxItem {
+ construction_method: ConstructionMethod,
+ /// Unused for ConstructionMethod::Idat
+ extents: TryVec<Extent>,
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.3
+///
+/// Note: per MIAF (ISO 23000-22:2019) § 7.2.1.7:<br />
+/// > MIAF image items are constrained as follows:<br />
+/// > — `construction_method` shall be equal to 0 for MIAF image items that are coded image items.<br />
+/// > — `construction_method` shall be equal to 0 or 1 for MIAF image items that are derived image items.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ConstructionMethod {
+ File = 0,
+ Idat = 1,
+ Item = 2,
+}
+
+/// Describes a region where a item specified by an `ItemLocationBoxItem` is stored.
+/// The offset is `u64` since that's the maximum possible size and since the relative
+/// nature of `DataBox` means this can still possibly succeed even in the case
+/// that the raw value exceeds std::usize::MAX on platforms where that type is smaller
+/// than u64. However, `len` is stored as a `usize` since no value larger than
+/// `std::usize::MAX` can be used in a successful indexing operation in rust.
+/// `extent_index` is omitted since it's only used for ConstructionMethod::Item which
+/// is currently not implemented.
+#[derive(Clone, Debug)]
+enum Extent {
+ WithLength { offset: u64, len: usize },
+ ToEnd { offset: u64 },
+}
+
+#[derive(Debug, PartialEq, Eq, Default)]
+pub enum TrackType {
+ Audio,
+ Video,
+ Picture,
+ AuxiliaryVideo,
+ Metadata,
+ #[default]
+ Unknown,
+}
+
+// This type is used by mp4parse_capi since it needs to be passed from FFI consumers
+// The C-visible struct is renamed via mp4parse_capi/cbindgen.toml to match naming conventions
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ParseStrictness {
+ Permissive, // Error only on ambiguous inputs
+ #[default]
+ Normal, // Error on "shall" directives, log warnings for "should"
+ Strict, // Error on "should" directives
+}
+
+fn fail_with_status_if(violation: bool, status: Status) -> Result<()> {
+ let error = Error::from(status);
+ if violation {
+ Err(error)
+ } else {
+ warn!("{:?}", error);
+ Ok(())
+ }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum CodecType {
+ #[default]
+ Unknown,
+ MP3,
+ AAC,
+ FLAC,
+ Opus,
+ H264, // 14496-10
+ MP4V, // 14496-2
+ AV1,
+ VP9,
+ VP8,
+ EncryptedVideo,
+ EncryptedAudio,
+ LPCM, // QT
+ ALAC,
+ H263,
+ HEVC, // 23008-2
+ #[cfg(feature = "3gpp")]
+ AMRNB,
+ #[cfg(feature = "3gpp")]
+ AMRWB,
+}
+
+/// The media's global (mvhd) timescale in units per second.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct MediaTimeScale(pub u64);
+
+/// A time to be scaled by the media's global (mvhd) timescale.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct MediaScaledTime(pub u64);
+
+/// The track's local (mdhd) timescale.
+/// Members are timescale units per second and the track id.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TrackTimeScale<T: Num>(pub T, pub usize);
+
+/// A time to be scaled by the track's local (mdhd) timescale.
+/// Members are time in scale units and the track id.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TrackScaledTime<T>(pub T, pub usize);
+
+impl<T> std::ops::Add for TrackScaledTime<T>
+where
+ T: num_traits::CheckedAdd,
+{
+ type Output = Option<Self>;
+
+ fn add(self, other: TrackScaledTime<T>) -> Self::Output {
+ self.0.checked_add(&other.0).map(|sum| Self(sum, self.1))
+ }
+}
+
+#[derive(Debug, Default)]
+pub struct Track {
+ pub id: usize,
+ pub track_type: TrackType,
+ pub looped: Option<bool>,
+ pub empty_duration: Option<MediaScaledTime>,
+ pub edited_duration: Option<MediaScaledTime>,
+ pub media_time: Option<TrackScaledTime<u64>>,
+ pub timescale: Option<TrackTimeScale<u64>>,
+ pub duration: Option<TrackScaledTime<u64>>,
+ pub track_id: Option<u32>,
+ pub tkhd: Option<TrackHeaderBox>, // TODO(kinetik): find a nicer way to export this.
+ pub stsd: Option<SampleDescriptionBox>,
+ pub stts: Option<TimeToSampleBox>,
+ pub stsc: Option<SampleToChunkBox>,
+ pub stsz: Option<SampleSizeBox>,
+ pub stco: Option<ChunkOffsetBox>, // It is for stco or co64.
+ pub stss: Option<SyncSampleBox>,
+ pub ctts: Option<CompositionOffsetBox>,
+ pub tref: Option<TrackReferenceBox>,
+}
+
+impl Track {
+ fn new(id: usize) -> Track {
+ Track {
+ id,
+ ..Default::default()
+ }
+ }
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 4.2
+struct BMFFBox<'a, T: 'a> {
+ head: BoxHeader,
+ content: Take<&'a mut T>,
+}
+
+struct BoxIter<'a, T: 'a> {
+ src: &'a mut T,
+}
+
+impl<'a, T: Read> BoxIter<'a, T> {
+ fn new(src: &mut T) -> BoxIter<T> {
+ BoxIter { src }
+ }
+
+ fn next_box(&mut self) -> Result<Option<BMFFBox<T>>> {
+ let r = read_box_header(self.src);
+ match r {
+ Ok(h) => Ok(Some(BMFFBox {
+ head: h,
+ content: self.src.take(h.size.saturating_sub(h.offset)),
+ })),
+ Err(Error::UnexpectedEOF) => Ok(None),
+ Err(e) => Err(e),
+ }
+ }
+}
+
+impl<'a, T: Read> Read for BMFFBox<'a, T> {
+ fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+ self.content.read(buf)
+ }
+}
+
+impl<'a, T: Read> TryRead for BMFFBox<'a, T> {
+ fn try_read_to_end(&mut self, buf: &mut TryVec<u8>) -> std::io::Result<usize> {
+ fallible_collections::try_read_up_to(self, self.bytes_left(), buf)
+ }
+}
+
+impl<'a, T: Offset> Offset for BMFFBox<'a, T> {
+ fn offset(&self) -> u64 {
+ self.content.get_ref().offset()
+ }
+}
+
+impl<'a, T: Read> BMFFBox<'a, T> {
+ fn bytes_left(&self) -> u64 {
+ self.content.limit()
+ }
+
+ fn get_header(&self) -> &BoxHeader {
+ &self.head
+ }
+
+ fn box_iter<'b>(&'b mut self) -> BoxIter<BMFFBox<'a, T>> {
+ BoxIter::new(self)
+ }
+}
+
+impl<'a, T> Drop for BMFFBox<'a, T> {
+ fn drop(&mut self) {
+ if self.content.limit() > 0 {
+ let name: FourCC = From::from(self.head.name);
+ debug!("Dropping {} bytes in '{}'", self.content.limit(), name);
+ }
+ }
+}
+
+/// Read and parse a box header.
+///
+/// Call this first to determine the type of a particular mp4 box
+/// and its length. Used internally for dispatching to specific
+/// parsers for the internal content, or to get the length to
+/// skip unknown or uninteresting boxes.
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 4.2
+fn read_box_header<T: ReadBytesExt>(src: &mut T) -> Result<BoxHeader> {
+ let size32 = match be_u32(src) {
+ Ok(v) => v,
+ Err(error) => return Err(error),
+ };
+ let name = BoxType::from(be_u32(src)?);
+ let size = match size32 {
+ // valid only for top-level box and indicates it's the last box in the file. usually mdat.
+ 0 => {
+ if name == BoxType::MediaDataBox {
+ 0
+ } else {
+ return Err(Error::Unsupported("unknown sized box"));
+ }
+ }
+ 1 => be_u64(src)?,
+ _ => u64::from(size32),
+ };
+ trace!("read_box_header: name: {:?}, size: {}", name, size);
+ let mut offset = match size32 {
+ 1 => BoxHeader::MIN_LARGE_SIZE,
+ _ => BoxHeader::MIN_SIZE,
+ };
+ let uuid = if name == BoxType::UuidBox {
+ if size >= offset + 16 {
+ let mut buffer = [0u8; 16];
+ let count = src.read(&mut buffer)?;
+ offset += count.to_u64();
+ if count == 16 {
+ Some(buffer)
+ } else {
+ debug!("malformed uuid (short read)");
+ return Err(Error::UnexpectedEOF);
+ }
+ } else {
+ None
+ }
+ } else {
+ None
+ };
+ match size32 {
+ 0 => (),
+ 1 if offset > size => return Err(Error::from(Status::BoxBadWideSize)),
+ _ if offset > size => return Err(Error::from(Status::BoxBadSize)),
+ _ => (),
+ }
+ Ok(BoxHeader {
+ name,
+ size,
+ offset,
+ uuid,
+ })
+}
+
+/// Parse the extra header fields for a full box.
+fn read_fullbox_extra<T: ReadBytesExt>(src: &mut T) -> Result<(u8, u32)> {
+ let version = src.read_u8()?;
+ let flags_a = src.read_u8()?;
+ let flags_b = src.read_u8()?;
+ let flags_c = src.read_u8()?;
+ Ok((
+ version,
+ u32::from(flags_a) << 16 | u32::from(flags_b) << 8 | u32::from(flags_c),
+ ))
+}
+
+// Parse the extra fields for a full box whose flag fields must be zero.
+fn read_fullbox_version_no_flags<T: ReadBytesExt>(src: &mut T) -> Result<u8> {
+ let (version, flags) = read_fullbox_extra(src)?;
+
+ if flags != 0 {
+ return Err(Error::Unsupported("expected flags to be 0"));
+ }
+
+ Ok(version)
+}
+
+/// Skip over the entire contents of a box.
+fn skip_box_content<T: Read>(src: &mut BMFFBox<T>) -> Result<()> {
+ // Skip the contents of unknown chunks.
+ let to_skip = {
+ let header = src.get_header();
+ debug!("{:?} (skipped)", header);
+ header
+ .size
+ .checked_sub(header.offset)
+ .ok_or(Error::Unsupported("Skipping past unknown sized box"))?
+ };
+ assert_eq!(to_skip, src.bytes_left());
+ skip(src, to_skip)
+}
+
+/// Skip over the remain data of a box.
+fn skip_box_remain<T: Read>(src: &mut BMFFBox<T>) -> Result<()> {
+ let remain = {
+ let header = src.get_header();
+ let len = src.bytes_left();
+ debug!("remain {} (skipped) in {:?}", len, header);
+ len
+ };
+ skip(src, remain)
+}
+
+#[derive(Debug)]
+enum AvifImageType {
+ Primary,
+ Sequence,
+ Both,
+}
+
+impl AvifImageType {
+ fn has_primary(&self) -> bool {
+ match self {
+ Self::Primary | Self::Both => true,
+ Self::Sequence => false,
+ }
+ }
+
+ fn has_sequence(&self) -> bool {
+ match self {
+ Self::Primary => false,
+ Self::Sequence | Self::Both => true,
+ }
+ }
+}
+
+/// Read the contents of an AVIF file
+pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<AvifContext> {
+ debug!("read_avif(strictness: {:?})", strictness);
+
+ let mut f = OffsetReader::new(f);
+ let mut iter = BoxIter::new(&mut f);
+ let expected_image_type;
+ let mut unsupported_features = UnsupportedFeatures::new();
+
+ // 'ftyp' box must occur first; see ISOBMFF (ISO 14496-12:2020) § 4.3.1
+ let major_brand = if let Some(mut b) = iter.next_box()? {
+ if b.head.name == BoxType::FileTypeBox {
+ let ftyp = read_ftyp(&mut b)?;
+
+ let has_avif_brand = ftyp.contains(&AVIF_BRAND);
+ let has_avis_brand = ftyp.contains(&AVIS_BRAND);
+ let has_mif1_brand = ftyp.contains(&MIF1_BRAND);
+ let has_msf1_brand = ftyp.contains(&MSF1_BRAND);
+
+ let primary_image_expected = has_mif1_brand || has_avif_brand;
+ let image_sequence_expected = has_msf1_brand || has_avis_brand;
+
+ expected_image_type = if primary_image_expected && image_sequence_expected {
+ AvifImageType::Both
+ } else if primary_image_expected {
+ AvifImageType::Primary
+ } else if image_sequence_expected {
+ AvifImageType::Sequence
+ } else {
+ return Status::NoImage.into();
+ };
+ debug!("expected_image_type: {:?}", expected_image_type);
+
+ if primary_image_expected && !has_mif1_brand {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::MissingMif1Brand,
+ )?;
+ }
+
+ if !has_avif_brand && !has_avis_brand {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::MissingAvifOrAvisBrand,
+ )?;
+ }
+
+ ftyp.major_brand
+ } else {
+ return Status::FtypNotFirst.into();
+ }
+ } else {
+ return Status::FtypNotFirst.into();
+ };
+
+ let mut meta = None;
+ let mut image_sequence = None;
+ let mut media_storage = TryVec::new();
+
+ loop {
+ let mut b = match iter.next_box() {
+ Ok(Some(b)) => b,
+ Ok(_) => break,
+ Err(Error::UnexpectedEOF) => {
+ if strictness == ParseStrictness::Strict {
+ return Err(Error::UnexpectedEOF);
+ }
+ break;
+ }
+ Err(error) => return Err(error),
+ };
+
+ trace!("read_avif parsing {:?} box", b.head.name);
+ match b.head.name {
+ BoxType::MetadataBox => {
+ if meta.is_some() {
+ return Status::MetaBadQuantity.into();
+ }
+ meta = Some(read_avif_meta(
+ &mut b,
+ strictness,
+ &mut unsupported_features,
+ )?);
+ }
+ BoxType::MovieBox if expected_image_type.has_sequence() => {
+ if image_sequence.is_some() {
+ return Status::MoovBadQuantity.into();
+ }
+ image_sequence = Some(read_moov(&mut b, None)?);
+ }
+ BoxType::MediaDataBox => {
+ let file_offset = b.offset();
+ let data = if b.head.size == 0 {
+ // Unknown sized `mdat`, read in chunks until EOF.
+ const BUF_SIZE: usize = 64 * 1024;
+ let mut data = TryVec::with_capacity(BUF_SIZE)?;
+ loop {
+ let got = fallible_collections::try_read_up_to(
+ b.content.get_mut(),
+ BUF_SIZE as u64,
+ &mut data,
+ )?;
+ if got == 0 {
+ // Mark `content` as consumed.
+ b.content.set_limit(0);
+ break;
+ }
+ }
+ data
+ } else {
+ b.read_into_try_vec()?
+ };
+ media_storage.push(DataBox::from_mdat(file_offset, data))?;
+ }
+ _ => {
+ let result = skip_box_content(&mut b);
+ // Allow garbage at EOF if we aren't in strict mode.
+ if b.bytes_left() > 0 && strictness != ParseStrictness::Strict {
+ break;
+ }
+ result?;
+ }
+ }
+
+ check_parser_state!(b.content);
+ }
+
+ let AvifMeta {
+ item_references,
+ item_properties,
+ primary_item_id,
+ item_infos,
+ iloc_items,
+ item_data_box,
+ } = meta.ok_or_else(|| Error::from(Status::MetaBadQuantity))?;
+
+ let (alpha_item_id, premultiplied_alpha) = if let Some(primary_item_id) = primary_item_id {
+ let mut alpha_item_ids = item_references
+ .iter()
+ // Auxiliary image for the primary image
+ .filter(|iref| {
+ iref.to_item_id == primary_item_id
+ && iref.from_item_id != primary_item_id
+ && iref.item_type == b"auxl"
+ })
+ .map(|iref| iref.from_item_id)
+ // which has the alpha property
+ .filter(|&item_id| item_properties.is_alpha(item_id));
+ let alpha_item_id = alpha_item_ids.next();
+ if alpha_item_ids.next().is_some() {
+ return Status::MultipleAlpha.into();
+ }
+
+ let premultiplied_alpha = alpha_item_id.map_or(false, |alpha_item_id| {
+ item_references.iter().any(|iref| {
+ iref.from_item_id == primary_item_id
+ && iref.to_item_id == alpha_item_id
+ && iref.item_type == b"prem"
+ })
+ });
+
+ (alpha_item_id, premultiplied_alpha)
+ } else {
+ (None, false)
+ };
+
+ debug!("primary_item_id: {:?}", primary_item_id);
+ debug!("alpha_item_id: {:?}", alpha_item_id);
+ let mut primary_item = None;
+ let mut alpha_item = None;
+
+ // store data or record location of relevant items
+ for (item_id, loc) in iloc_items {
+ let item = if Some(item_id) == primary_item_id {
+ &mut primary_item
+ } else if Some(item_id) == alpha_item_id {
+ &mut alpha_item
+ } else {
+ continue;
+ };
+
+ assert!(item.is_none());
+
+ // If our item is spread over multiple extents, we'll need to copy it
+ // into a contiguous buffer. Otherwise, we can just store the extent
+ // and return a pointer into the mdat/idat later to avoid the copy.
+ if loc.extents.len() > 1 {
+ *item = Some(AvifItem::with_inline_data(item_id))
+ }
+
+ trace!(
+ "{:?} construction_method: {:?}",
+ item_id,
+ loc.construction_method
+ );
+
+ // Generalize the process of connecting items to their data; returns
+ // true if the extent is successfully added to the AvifItem
+ let mut find_and_add_to_item = |extent: &Extent, dat: &DataBox| -> Result<bool> {
+ if let Some(extent_slice) = dat.get(extent) {
+ match item {
+ None => {
+ trace!("Using IsobmffItem::Location");
+ *item = Some(AvifItem {
+ id: item_id,
+ image_data: dat.location(extent),
+ });
+ }
+ Some(AvifItem {
+ image_data: IsobmffItem::Data(bytes),
+ ..
+ }) => {
+ trace!("Using IsobmffItem::Data");
+ // We could potentially optimize memory usage by trying to avoid reading
+ // or storing dat boxes which aren't used by our API, but for now it seems
+ // like unnecessary complexity
+ bytes.extend_from_slice(extent_slice)?;
+ }
+ _ => unreachable!(),
+ }
+ return Ok(true);
+ }
+ Ok(false)
+ };
+
+ match loc.construction_method {
+ ConstructionMethod::File => {
+ for extent in loc.extents {
+ let mut found = false;
+ // try to find an mdat which contains the extent
+ for mdat in media_storage.iter() {
+ if find_and_add_to_item(&extent, mdat)? {
+ found = true;
+ break;
+ }
+ }
+
+ if !found {
+ return Status::IlocNotFound.into();
+ }
+ }
+ }
+ ConstructionMethod::Idat => {
+ if let Some(idat) = &item_data_box {
+ for extent in loc.extents {
+ let found = find_and_add_to_item(&extent, idat)?;
+ if !found {
+ return Status::IlocNotFound.into();
+ }
+ }
+ } else {
+ return Status::IdatMissing.into();
+ }
+ }
+ ConstructionMethod::Item => {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::ConstructionMethod,
+ )?;
+ }
+ }
+
+ assert!(item.is_some());
+ }
+
+ if (primary_item_id.is_some() && primary_item.is_none())
+ || (alpha_item_id.is_some() && alpha_item.is_none())
+ {
+ fail_with_status_if(strictness == ParseStrictness::Strict, Status::PitmNotFound)?;
+ }
+
+ assert!(primary_item.is_none() || primary_item_id.is_some());
+ assert!(alpha_item.is_none() || alpha_item_id.is_some());
+
+ if expected_image_type.has_primary() && primary_item_id.is_none() {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::PitmMissing,
+ )?;
+ }
+
+ // Lacking a brand that requires them, it's fine for moov boxes to exist in
+ // BMFF files; they're simply ignored
+ if expected_image_type.has_sequence() && image_sequence.is_none() {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::MoovMissing,
+ )?;
+ }
+
+ // Returns true iff `id` is `Some` and there is no corresponding property for it
+ let missing_property_for = |id: Option<ItemId>, property: BoxType| -> bool {
+ id.map_or(false, |id| {
+ item_properties
+ .get(id, property)
+ .map_or(true, |opt| opt.is_none())
+ })
+ };
+
+ // Generalize the property checks so we can apply them to primary and alpha items
+ let mut check_image_item = |item: &mut Option<AvifItem>| -> Result<()> {
+ let item_id = item.as_ref().map(|item| item.id);
+ let item_type = item_id.and_then(|item_id| {
+ item_infos
+ .iter()
+ .find(|item_info| item_id == item_info.item_id)
+ .map(|item_info| item_info.item_type)
+ });
+
+ match item_type.map(u32::to_be_bytes).as_ref() {
+ Some(b"av01") => {
+ if missing_property_for(item_id, BoxType::AV1CodecConfigurationBox) {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::Av1cMissing,
+ )?;
+ }
+
+ if missing_property_for(item_id, BoxType::PixelInformationBox) {
+ // The requirement to include pixi is in the process of being changed
+ // to allowing its omission to imply a default value. In anticipation
+ // of that, only give an error in strict mode
+ // See https://github.com/MPEGGroup/MIAF/issues/9
+ fail_with_status_if(
+ if cfg!(feature = "missing-pixi-permitted") {
+ strictness == ParseStrictness::Strict
+ } else {
+ strictness != ParseStrictness::Permissive
+ },
+ Status::PixiMissing,
+ )?;
+ }
+
+ if missing_property_for(item_id, BoxType::ImageSpatialExtentsProperty) {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::IspeMissing,
+ )?;
+ }
+ }
+ Some(b"grid") => {
+ // TODO: https://github.com/mozilla/mp4parse-rust/issues/198
+ unsupported_features.insert(Feature::Grid);
+ *item = None;
+ }
+ Some(_other_type) => return Status::ImageItemType.into(),
+ None => {
+ if item.is_some() {
+ return Status::ItemTypeMissing.into();
+ }
+ }
+ }
+
+ if let Some(AvifItem { id, .. }) = item {
+ if item_properties.forbidden_items.contains(id) {
+ error!("Not processing item id {:?} since it is associated with essential, but unsupported properties", id);
+ *item = None;
+ }
+ }
+
+ Ok(())
+ };
+
+ check_image_item(&mut primary_item)?;
+ check_image_item(&mut alpha_item)?;
+
+ Ok(AvifContext {
+ strictness,
+ media_storage,
+ item_data_box,
+ primary_item,
+ alpha_item,
+ premultiplied_alpha,
+ item_properties,
+ major_brand,
+ sequence: image_sequence,
+ unsupported_features,
+ })
+}
+
+/// Parse a metadata box in the context of an AVIF
+/// Currently requires the primary item to be an av01 item type and generates
+/// an error otherwise.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.1
+fn read_avif_meta<T: Read + Offset>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+ unsupported_features: &mut UnsupportedFeatures,
+) -> Result<AvifMeta> {
+ let version = read_fullbox_version_no_flags(src)?;
+
+ if version != 0 {
+ return Err(Error::Unsupported("unsupported meta version"));
+ }
+
+ let mut read_handler_box = false;
+ let mut primary_item_id = None;
+ let mut item_infos = None;
+ let mut iloc_items = None;
+ let mut item_references = None;
+ let mut item_properties = None;
+ let mut item_data_box = None;
+
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ trace!("read_avif_meta parsing {:?} box", b.head.name);
+
+ if !read_handler_box && b.head.name != BoxType::HandlerBox {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::HdlrNotFirst,
+ )?;
+ }
+
+ match b.head.name {
+ BoxType::HandlerBox => {
+ if read_handler_box {
+ return Status::HdrlBadQuantity.into();
+ }
+ let HandlerBox { handler_type } = read_hdlr(&mut b, strictness)?;
+ if handler_type != b"pict" {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::HdlrTypeNotPict,
+ )?;
+ }
+ read_handler_box = true;
+ }
+ BoxType::ItemInfoBox => {
+ if item_infos.is_some() {
+ return Status::IinfBadQuantity.into();
+ }
+ item_infos = Some(read_iinf(&mut b, strictness, unsupported_features)?);
+ }
+ BoxType::ItemLocationBox => {
+ if iloc_items.is_some() {
+ return Status::IlocBadQuantity.into();
+ }
+ iloc_items = Some(read_iloc(&mut b)?);
+ }
+ BoxType::PrimaryItemBox => {
+ if primary_item_id.is_some() {
+ return Status::PitmBadQuantity.into();
+ }
+ primary_item_id = Some(read_pitm(&mut b)?);
+ }
+ BoxType::ItemReferenceBox => {
+ if item_references.is_some() {
+ return Status::IrefBadQuantity.into();
+ }
+ item_references = Some(read_iref(&mut b)?);
+ }
+ BoxType::ItemPropertiesBox => {
+ if item_properties.is_some() {
+ return Status::IprpBadQuantity.into();
+ }
+ item_properties = Some(read_iprp(
+ &mut b,
+ MIF1_BRAND,
+ strictness,
+ unsupported_features,
+ )?);
+ }
+ BoxType::ItemDataBox => {
+ if item_data_box.is_some() {
+ return Status::IdatBadQuantity.into();
+ }
+ let data = b.read_into_try_vec()?;
+ item_data_box = Some(DataBox::from_idat(data));
+ }
+ _ => skip_box_content(&mut b)?,
+ }
+
+ check_parser_state!(b.content);
+ }
+
+ Ok(AvifMeta {
+ item_properties: item_properties.unwrap_or_default(),
+ item_references: item_references.unwrap_or_default(),
+ primary_item_id,
+ item_infos: item_infos.unwrap_or_default(),
+ iloc_items: iloc_items.unwrap_or_default(),
+ item_data_box,
+ })
+}
+
+/// Parse a Primary Item Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.4
+fn read_pitm<T: Read>(src: &mut BMFFBox<T>) -> Result<ItemId> {
+ let version = read_fullbox_version_no_flags(src)?;
+
+ let item_id = ItemId(match version {
+ 0 => be_u16(src)?.into(),
+ 1 => be_u32(src)?,
+ _ => return Err(Error::Unsupported("unsupported pitm version")),
+ });
+
+ Ok(item_id)
+}
+
+/// Parse an Item Information Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.6
+fn read_iinf<T: Read>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+ unsupported_features: &mut UnsupportedFeatures,
+) -> Result<TryVec<ItemInfoEntry>> {
+ let version = read_fullbox_version_no_flags(src)?;
+
+ match version {
+ 0 | 1 => (),
+ _ => return Err(Error::Unsupported("unsupported iinf version")),
+ }
+
+ let entry_count = if version == 0 {
+ be_u16(src)?.to_usize()
+ } else {
+ be_u32(src)?.to_usize()
+ };
+ let mut item_infos = TryVec::with_capacity(entry_count)?;
+
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ if b.head.name != BoxType::ItemInfoEntry {
+ return Status::IinfBadChild.into();
+ }
+
+ if let Some(infe) = read_infe(&mut b, strictness, unsupported_features)? {
+ item_infos.push(infe)?;
+ }
+
+ check_parser_state!(b.content);
+ }
+
+ Ok(item_infos)
+}
+
+/// A simple wrapper to interpret a u32 as a 4-byte string in big-endian
+/// order without requiring any allocation.
+struct U32BE(u32);
+
+impl std::fmt::Display for U32BE {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match std::str::from_utf8(&self.0.to_be_bytes()) {
+ Ok(s) => f.write_str(s),
+ Err(_) => write!(f, "{:x?}", self.0),
+ }
+ }
+}
+
+/// Parse an Item Info Entry
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.6.2
+fn read_infe<T: Read>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+ unsupported_features: &mut UnsupportedFeatures,
+) -> Result<Option<ItemInfoEntry>> {
+ let (version, flags) = read_fullbox_extra(src)?;
+
+ // According to the standard, it seems the flags field shall be 0, but at
+ // least one sample AVIF image has a nonzero value.
+ // See https://github.com/AOMediaCodec/av1-avif/issues/146
+ if flags != 0 {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::InfeFlagsNonzero,
+ )?;
+ }
+
+ // mif1 brand (see HEIF (ISO 23008-12:2017) § 10.2.1) only requires v2 and 3
+ let item_id = ItemId(match version {
+ 2 => be_u16(src)?.into(),
+ 3 => be_u32(src)?,
+ _ => return Err(Error::Unsupported("unsupported version in 'infe' box")),
+ });
+
+ let item_protection_index = be_u16(src)?;
+
+ let item_type = be_u32(src)?;
+ debug!("infe {:?} item_type: {}", item_id, U32BE(item_type));
+
+ // There are some additional fields here, but they're not of interest to us
+ skip_box_remain(src)?;
+
+ if item_protection_index != 0 {
+ unsupported_features.insert(Feature::Ipro);
+ Ok(None)
+ } else {
+ Ok(Some(ItemInfoEntry { item_id, item_type }))
+ }
+}
+
+/// Parse an Item Reference Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.12
+fn read_iref<T: Read>(src: &mut BMFFBox<T>) -> Result<TryVec<SingleItemTypeReferenceBox>> {
+ let mut item_references = TryVec::new();
+ let version = read_fullbox_version_no_flags(src)?;
+ if version > 1 {
+ return Err(Error::Unsupported("iref version"));
+ }
+
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ trace!("read_iref parsing {:?} referenceType", b.head.name);
+ let from_item_id = ItemId::read(&mut b, version)?;
+ let reference_count = be_u16(&mut b)?;
+ item_references.reserve(reference_count.to_usize())?;
+ for _ in 0..reference_count {
+ let to_item_id = ItemId::read(&mut b, version)?;
+ if from_item_id == to_item_id {
+ return Status::IrefRecursion.into();
+ }
+ item_references.push(SingleItemTypeReferenceBox {
+ item_type: b.head.name.into(),
+ from_item_id,
+ to_item_id,
+ })?;
+ }
+ check_parser_state!(b.content);
+ }
+
+ trace!("read_iref -> {:#?}", item_references);
+
+ Ok(item_references)
+}
+
+/// Parse an Item Properties Box
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14)
+///
+/// Note: HEIF (ISO 23008-12:2017) § 9.3.1 also defines the `iprp` box and
+/// related types, but lacks additional requirements specified in 14496-12:2020.
+///
+/// Note: Currently HEIF (ISO 23008-12:2017) § 6.5.5.1 specifies "At most one"
+/// `colr` box per item, but this is being amended in [DIS 23008-12](https://www.iso.org/standard/83650.html).
+/// The new text is likely to be "At most one for a given value of `colour_type`",
+/// so this implementation adheres to that language for forward compatibility.
+fn read_iprp<T: Read>(
+ src: &mut BMFFBox<T>,
+ brand: FourCC,
+ strictness: ParseStrictness,
+ unsupported_features: &mut UnsupportedFeatures,
+) -> Result<ItemPropertiesBox> {
+ let mut iter = src.box_iter();
+
+ let properties = match iter.next_box()? {
+ Some(mut b) if b.head.name == BoxType::ItemPropertyContainerBox => {
+ read_ipco(&mut b, strictness)
+ }
+ Some(_) => Status::IprpBadChild.into(),
+ None => Err(Error::UnexpectedEOF),
+ }?;
+
+ let mut ipma_version_and_flag_values_seen = TryVec::with_capacity(1)?;
+ let mut association_entries = TryVec::<ItemPropertyAssociationEntry>::new();
+ let mut forbidden_items = TryVec::new();
+
+ while let Some(mut b) = iter.next_box()? {
+ if b.head.name != BoxType::ItemPropertyAssociationBox {
+ return Status::IprpBadChild.into();
+ }
+
+ let (version, flags) = read_fullbox_extra(&mut b)?;
+ if ipma_version_and_flag_values_seen.contains(&(version, flags)) {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::IpmaBadQuantity,
+ )?;
+ }
+ if flags != 0 && properties.len() <= 127 {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::IpmaFlagsNonzero,
+ )?;
+ }
+ ipma_version_and_flag_values_seen.push((version, flags))?;
+ for association_entry in read_ipma(&mut b, strictness, version, flags)? {
+ if forbidden_items.contains(&association_entry.item_id) {
+ warn!(
+ "Skipping {:?} since the item referenced shall not be processed",
+ association_entry
+ );
+ }
+
+ if let Some(previous_entry) = association_entries
+ .iter()
+ .find(|e| association_entry.item_id == e.item_id)
+ {
+ error!(
+ "Duplicate ipma entries for item_id\n1: {:?}\n2: {:?}",
+ previous_entry, association_entry
+ );
+ // It's technically possible to make sense of this situation by merging ipma
+ // boxes, but this is a "shall" requirement, so we'd only do it in
+ // ParseStrictness::Permissive mode, and this hasn't shown up in the wild
+ return Status::IpmaDuplicateItemId.into();
+ }
+
+ const TRANSFORM_ORDER: &[BoxType] = &[
+ BoxType::ImageSpatialExtentsProperty,
+ BoxType::CleanApertureBox,
+ BoxType::ImageRotation,
+ BoxType::ImageMirror,
+ ];
+ let mut prev_transform_index = None;
+ // Realistically, there should only ever be 1 nclx and 1 icc
+ let mut colour_type_indexes: TryHashMap<FourCC, PropertyIndex> =
+ TryHashMap::with_capacity(2)?;
+
+ for a in &association_entry.associations {
+ if a.property_index == PropertyIndex(0) {
+ if a.essential {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::IpmaIndexZeroNoEssential,
+ )?;
+ }
+ continue;
+ }
+
+ if let Some(property) = properties.get(&a.property_index) {
+ assert!(brand == MIF1_BRAND);
+
+ let feature = Feature::try_from(property);
+ let property_supported = match feature {
+ Ok(feature) => {
+ if feature.supported() {
+ true
+ } else {
+ unsupported_features.insert(feature);
+ false
+ }
+ }
+ Err(_) => false,
+ };
+
+ if !property_supported {
+ if a.essential && strictness != ParseStrictness::Permissive {
+ error!("Unsupported essential property {:?}", property);
+ forbidden_items.push(association_entry.item_id)?;
+ } else {
+ debug!(
+ "Ignoring unknown {} property {:?}",
+ if a.essential {
+ "essential"
+ } else {
+ "non-essential"
+ },
+ property
+ );
+ }
+ }
+
+ // Check additional requirements on specific properties
+ match property {
+ ItemProperty::AV1Config(_)
+ | ItemProperty::CleanAperture
+ | ItemProperty::Mirroring(_)
+ | ItemProperty::Rotation(_) => {
+ if !a.essential {
+ warn!("{:?} is missing required 'essential' bit", property);
+ // This is a "shall", but it is likely to change, so only
+ // fail if using strict parsing.
+ // See https://github.com/mozilla/mp4parse-rust/issues/284
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::TxformNoEssential,
+ )?;
+ }
+ }
+
+ // NOTE: this is contrary to the published specification; see doc comment
+ // at the beginning of this function for more details
+ ItemProperty::Colour(colr) => {
+ let colour_type = colr.colour_type();
+ if let Some(prev_colr_index) = colour_type_indexes.get(&colour_type) {
+ warn!(
+ "Multiple '{}' type colr associations with {:?}: {:?} and {:?}",
+ colour_type,
+ association_entry.item_id,
+ a.property_index,
+ prev_colr_index
+ );
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::ColrBadQuantity,
+ )?;
+ } else {
+ colour_type_indexes.insert(colour_type, a.property_index)?;
+ }
+ }
+
+ // The following properties are unsupported, but we still enforce that
+ // they've been correctly marked as essential or not.
+ ItemProperty::LayeredImageIndexing => {
+ assert!(feature.is_ok() && unsupported_features.contains(feature?));
+ if a.essential {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::A1lxEssential,
+ )?;
+ }
+ }
+
+ ItemProperty::LayerSelection => {
+ assert!(feature.is_ok() && unsupported_features.contains(feature?));
+ if a.essential {
+ assert!(
+ forbidden_items.contains(&association_entry.item_id)
+ || strictness == ParseStrictness::Permissive
+ );
+ } else {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::LselNoEssential,
+ )?;
+ }
+ }
+
+ ItemProperty::OperatingPointSelector => {
+ assert!(feature.is_ok() && unsupported_features.contains(feature?));
+ if a.essential {
+ assert!(
+ forbidden_items.contains(&association_entry.item_id)
+ || strictness == ParseStrictness::Permissive
+ );
+ } else {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::A1opNoEssential,
+ )?;
+ }
+ }
+
+ other_property => {
+ trace!("No additional checks for {:?}", other_property);
+ }
+ }
+
+ if let Some(transform_index) = TRANSFORM_ORDER
+ .iter()
+ .position(|t| *t == BoxType::from(property))
+ {
+ if let Some(prev) = prev_transform_index {
+ if prev >= transform_index {
+ error!(
+ "Invalid property order: {:?} after {:?}",
+ TRANSFORM_ORDER[transform_index], TRANSFORM_ORDER[prev]
+ );
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ if TRANSFORM_ORDER[transform_index]
+ == BoxType::ImageSpatialExtentsProperty
+ {
+ Status::TxformBeforeIspe
+ } else {
+ Status::TxformOrder
+ },
+ )?;
+ }
+ }
+ prev_transform_index = Some(transform_index);
+ }
+ } else {
+ error!(
+ "Missing property at {:?} for {:?}",
+ a.property_index, association_entry.item_id
+ );
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::IpmaBadIndex,
+ )?;
+ }
+ }
+ association_entries.push(association_entry)?
+ }
+
+ check_parser_state!(b.content);
+ }
+
+ let iprp = ItemPropertiesBox {
+ properties,
+ association_entries,
+ forbidden_items,
+ };
+ trace!("read_iprp -> {:#?}", iprp);
+ Ok(iprp)
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+/// Variants with no associated data are recognized but not necessarily supported.
+/// See [`Feature`] to determine support.
+#[derive(Debug)]
+pub enum ItemProperty {
+ AuxiliaryType(AuxiliaryTypeProperty),
+ AV1Config(AV1ConfigBox),
+ Channels(PixelInformation),
+ CleanAperture,
+ Colour(ColourInformation),
+ ImageSpatialExtents(ImageSpatialExtentsProperty),
+ LayeredImageIndexing,
+ LayerSelection,
+ Mirroring(ImageMirror),
+ OperatingPointSelector,
+ PixelAspectRatio(PixelAspectRatio),
+ Rotation(ImageRotation),
+ /// Necessary to validate property indices in read_iprp
+ Unsupported(BoxType),
+}
+
+impl From<&ItemProperty> for BoxType {
+ fn from(item_property: &ItemProperty) -> Self {
+ match item_property {
+ ItemProperty::AuxiliaryType(_) => BoxType::AuxiliaryTypeProperty,
+ ItemProperty::AV1Config(_) => BoxType::AV1CodecConfigurationBox,
+ ItemProperty::CleanAperture => BoxType::CleanApertureBox,
+ ItemProperty::Colour(_) => BoxType::ColourInformationBox,
+ ItemProperty::LayeredImageIndexing => BoxType::AV1LayeredImageIndexingProperty,
+ ItemProperty::LayerSelection => BoxType::LayerSelectorProperty,
+ ItemProperty::Mirroring(_) => BoxType::ImageMirror,
+ ItemProperty::OperatingPointSelector => BoxType::OperatingPointSelectorProperty,
+ ItemProperty::PixelAspectRatio(_) => BoxType::PixelAspectRatioBox,
+ ItemProperty::Rotation(_) => BoxType::ImageRotation,
+ ItemProperty::ImageSpatialExtents(_) => BoxType::ImageSpatialExtentsProperty,
+ ItemProperty::Channels(_) => BoxType::PixelInformationBox,
+ ItemProperty::Unsupported(box_type) => *box_type,
+ }
+ }
+}
+
+#[derive(Debug)]
+struct ItemPropertyAssociationEntry {
+ item_id: ItemId,
+ associations: TryVec<Association>,
+}
+
+/// For storing ItemPropertyAssociation data
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+#[derive(Debug)]
+struct Association {
+ essential: bool,
+ property_index: PropertyIndex,
+}
+
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+///
+/// The properties themselves are stored in `properties`, but the items they're
+/// associated with are stored in `association_entries`. It's necessary to
+/// maintain this indirection because multiple items can reference the same
+/// property. For example, both the primary item and alpha item can share the
+/// same [`ImageSpatialExtentsProperty`].
+#[derive(Debug, Default)]
+pub struct ItemPropertiesBox {
+ /// `ItemPropertyContainerBox property_container` in the spec
+ properties: TryHashMap<PropertyIndex, ItemProperty>,
+ /// `ItemPropertyAssociationBox association[]` in the spec
+ association_entries: TryVec<ItemPropertyAssociationEntry>,
+ /// Items that shall not be processed due to unsupported properties that
+ /// have been marked essential.
+ /// See HEIF (ISO/IEC 23008-12:2017) § 9.3.1
+ forbidden_items: TryVec<ItemId>,
+}
+
+impl ItemPropertiesBox {
+ /// For displayable images `av1C`, `pixi` and `ispe` are mandatory, `colr`
+ /// is typically included too, so we might as well use an even power of 2.
+ const MIN_PROPERTIES: usize = 4;
+
+ fn is_alpha(&self, item_id: ItemId) -> bool {
+ match self.get(item_id, BoxType::AuxiliaryTypeProperty) {
+ Ok(Some(ItemProperty::AuxiliaryType(urn))) => {
+ urn.aux_type.as_slice() == "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha".as_bytes()
+ }
+ Ok(Some(other_property)) => panic!("property key mismatch: {:?}", other_property),
+ Ok(None) => false,
+ Err(e) => {
+ error!(
+ "is_alpha: Error checking AuxiliaryTypeProperty ({}), returning false",
+ e
+ );
+ false
+ }
+ }
+ }
+
+ fn get(&self, item_id: ItemId, property_type: BoxType) -> Result<Option<&ItemProperty>> {
+ match self
+ .get_multiple(item_id, |prop| BoxType::from(prop) == property_type)?
+ .as_slice()
+ {
+ &[] => Ok(None),
+ &[single_value] => Ok(Some(single_value)),
+ multiple_values => {
+ error!(
+ "Multiple values for {:?}: {:?}",
+ property_type, multiple_values
+ );
+ // TODO: add test
+ Status::IprpConflict.into()
+ }
+ }
+ }
+
+ fn get_multiple(
+ &self,
+ item_id: ItemId,
+ filter: impl Fn(&ItemProperty) -> bool,
+ ) -> Result<TryVec<&ItemProperty>> {
+ let mut values = TryVec::new();
+ for entry in &self.association_entries {
+ for a in &entry.associations {
+ if entry.item_id == item_id {
+ match self.properties.get(&a.property_index) {
+ Some(ItemProperty::Unsupported(_)) => {}
+ Some(property) if filter(property) => values.push(property)?,
+ _ => {}
+ }
+ }
+ }
+ }
+
+ Ok(values)
+ }
+}
+
+/// An upper bound which can be used to check overflow at compile time
+trait UpperBounded {
+ const MAX: u64;
+}
+
+/// Implement type $name as a newtype wrapper around an unsigned int which
+/// implements the UpperBounded trait.
+macro_rules! impl_bounded {
+ ( $name:ident, $inner:ty ) => {
+ #[derive(Clone, Copy)]
+ pub struct $name($inner);
+
+ impl $name {
+ pub const fn new(n: $inner) -> Self {
+ Self(n)
+ }
+
+ #[allow(dead_code)]
+ pub fn get(self) -> $inner {
+ self.0
+ }
+ }
+
+ impl UpperBounded for $name {
+ const MAX: u64 = <$inner>::MAX as u64;
+ }
+ };
+}
+
+/// Implement type $name as a type representing the product of two unsigned ints
+/// which implements the UpperBounded trait.
+macro_rules! impl_bounded_product {
+ ( $name:ident, $multiplier:ty, $multiplicand:ty, $inner:ty) => {
+ #[derive(Clone, Copy)]
+ pub struct $name($inner);
+
+ impl $name {
+ pub fn new(value: $inner) -> Self {
+ assert!(value <= Self::MAX);
+ Self(value)
+ }
+
+ pub fn get(self) -> $inner {
+ self.0
+ }
+ }
+
+ impl UpperBounded for $name {
+ const MAX: u64 = <$multiplier>::MAX * <$multiplicand>::MAX;
+ }
+ };
+}
+
+mod bounded_uints {
+ use crate::UpperBounded;
+
+ impl_bounded!(U8, u8);
+ impl_bounded!(U16, u16);
+ impl_bounded!(U32, u32);
+ impl_bounded!(U64, u64);
+
+ impl_bounded_product!(U32MulU8, U32, U8, u64);
+ impl_bounded_product!(U32MulU16, U32, U16, u64);
+
+ impl UpperBounded for std::num::NonZeroU8 {
+ const MAX: u64 = u8::MAX as u64;
+ }
+}
+
+use crate::bounded_uints::*;
+
+/// Implement the multiplication operator for $lhs * $rhs giving $output, which
+/// is internally represented as $inner. The operation is statically checked
+/// to ensure the product won't overflow $inner, nor exceed <$output>::MAX.
+macro_rules! impl_mul {
+ ( ($lhs:ty , $rhs:ty) => ($output:ty, $inner:ty) ) => {
+ impl std::ops::Mul<$rhs> for $lhs {
+ type Output = $output;
+
+ fn mul(self, rhs: $rhs) -> Self::Output {
+ static_assertions::const_assert!(
+ <$output as UpperBounded>::MAX <= <$inner>::MAX as u64
+ );
+ static_assertions::const_assert!(
+ <$lhs as UpperBounded>::MAX * <$rhs as UpperBounded>::MAX
+ <= <$output as UpperBounded>::MAX
+ );
+
+ let lhs: $inner = self.get().into();
+ let rhs: $inner = rhs.get().into();
+ Self::Output::new(lhs.checked_mul(rhs).expect("infallible"))
+ }
+ }
+ };
+}
+
+impl_mul!((U8, std::num::NonZeroU8) => (U16, u16));
+impl_mul!((U32, std::num::NonZeroU8) => (U32MulU8, u64));
+impl_mul!((U32, U16) => (U32MulU16, u64));
+
+impl std::ops::Add<U32MulU16> for U32MulU8 {
+ type Output = U64;
+
+ fn add(self, rhs: U32MulU16) -> Self::Output {
+ static_assertions::const_assert!(U32MulU8::MAX + U32MulU16::MAX < U64::MAX);
+ let lhs: u64 = self.get();
+ let rhs: u64 = rhs.get();
+ Self::Output::new(lhs.checked_add(rhs).expect("infallible"))
+ }
+}
+
+const MAX_IPMA_ASSOCIATION_COUNT: U8 = U8::new(u8::MAX);
+
+/// After reading only the `entry_count` field of an ipma box, we can check its
+/// basic validity and calculate (assuming validity) the number of associations
+/// which will be contained (allowing preallocation of the storage).
+/// All the arithmetic is compile-time verified to not overflow via supporting
+/// types implementing the UpperBounded trait. Types are declared explicitly to
+/// show there isn't any accidental inference to primitive types.
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+fn calculate_ipma_total_associations(
+ version: u8,
+ bytes_left: u64,
+ entry_count: U32,
+ num_association_bytes: std::num::NonZeroU8,
+) -> Result<usize> {
+ let min_entry_bytes =
+ std::num::NonZeroU8::new(1 /* association_count */ + if version == 0 { 2 } else { 4 })
+ .unwrap();
+
+ let total_non_association_bytes: U32MulU8 = entry_count * min_entry_bytes;
+ let total_association_bytes: u64 =
+ if let Some(difference) = bytes_left.checked_sub(total_non_association_bytes.get()) {
+ // All the storage for the `essential` and `property_index` parts (assuming a valid ipma box size)
+ difference
+ } else {
+ return Status::IpmaTooSmall.into();
+ };
+
+ let max_association_bytes_per_entry: U16 = MAX_IPMA_ASSOCIATION_COUNT * num_association_bytes;
+ let max_total_association_bytes: U32MulU16 = entry_count * max_association_bytes_per_entry;
+ let max_bytes_left: U64 = total_non_association_bytes + max_total_association_bytes;
+
+ if bytes_left > max_bytes_left.get() {
+ return Status::IpmaTooBig.into();
+ }
+
+ let total_associations: u64 = total_association_bytes / u64::from(num_association_bytes.get());
+
+ Ok(total_associations.try_into()?)
+}
+
+/// Parse an ItemPropertyAssociation box
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+fn read_ipma<T: Read>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+ version: u8,
+ flags: u32,
+) -> Result<TryVec<ItemPropertyAssociationEntry>> {
+ let entry_count = be_u32(src)?;
+ let num_association_bytes =
+ std::num::NonZeroU8::new(if flags & 1 == 1 { 2 } else { 1 }).unwrap();
+
+ let total_associations = calculate_ipma_total_associations(
+ version,
+ src.bytes_left(),
+ U32::new(entry_count),
+ num_association_bytes,
+ )?;
+ // Assuming most items will have at least `MIN_PROPERTIES` and knowing the
+ // total number of item -> property associations (`total_associations`),
+ // we can provide a good estimate for how many elements we'll need in this
+ // vector, even though we don't know precisely how many items there will be
+ // properties for.
+ let mut entries = TryVec::<ItemPropertyAssociationEntry>::with_capacity(
+ total_associations / ItemPropertiesBox::MIN_PROPERTIES,
+ )?;
+
+ for _ in 0..entry_count {
+ let item_id = ItemId::read(src, version)?;
+
+ if let Some(previous_association) = entries.last() {
+ #[allow(clippy::comparison_chain)]
+ if previous_association.item_id > item_id {
+ return Status::IpmaBadItemOrder.into();
+ } else if previous_association.item_id == item_id {
+ return Status::IpmaDuplicateItemId.into();
+ }
+ }
+
+ let association_count = src.read_u8()?;
+ let mut associations = TryVec::with_capacity(association_count.to_usize())?;
+ for _ in 0..association_count {
+ let association = src
+ .take(num_association_bytes.get().into())
+ .read_into_try_vec()?;
+ let mut association = BitReader::new(association.as_slice());
+ let essential = association.read_bool()?;
+ let property_index =
+ PropertyIndex(association.read_u16(association.remaining().try_into()?)?);
+ associations.push(Association {
+ essential,
+ property_index,
+ })?;
+ }
+
+ entries.push(ItemPropertyAssociationEntry {
+ item_id,
+ associations,
+ })?;
+ }
+
+ check_parser_state!(src.content);
+
+ if version != 0 {
+ if let Some(ItemPropertyAssociationEntry {
+ item_id: max_item_id,
+ ..
+ }) = entries.last()
+ {
+ if *max_item_id <= ItemId(u16::MAX.into()) {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::IpmaBadVersion,
+ )?;
+ }
+ }
+ }
+
+ trace!("read_ipma -> {:#?}", entries);
+
+ Ok(entries)
+}
+
+/// Parse an ItemPropertyContainerBox
+///
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.14.1
+fn read_ipco<T: Read>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+) -> Result<TryHashMap<PropertyIndex, ItemProperty>> {
+ let mut properties = TryHashMap::with_capacity(ItemPropertiesBox::MIN_PROPERTIES)?;
+
+ let mut index = PropertyIndex(1); // ipma uses 1-based indexing
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ let property = match b.head.name {
+ BoxType::AuxiliaryTypeProperty => ItemProperty::AuxiliaryType(read_auxc(&mut b)?),
+ BoxType::AV1CodecConfigurationBox => ItemProperty::AV1Config(read_av1c(&mut b)?),
+ BoxType::ColourInformationBox => ItemProperty::Colour(read_colr(&mut b, strictness)?),
+ BoxType::ImageMirror => ItemProperty::Mirroring(read_imir(&mut b)?),
+ BoxType::ImageRotation => ItemProperty::Rotation(read_irot(&mut b)?),
+ BoxType::ImageSpatialExtentsProperty => {
+ ItemProperty::ImageSpatialExtents(read_ispe(&mut b)?)
+ }
+ BoxType::PixelAspectRatioBox => ItemProperty::PixelAspectRatio(read_pasp(&mut b)?),
+ BoxType::PixelInformationBox => ItemProperty::Channels(read_pixi(&mut b)?),
+
+ other_box_type => {
+ // Even if we didn't do anything with other property types, we still store
+ // a record at the index to identify invalid indices in ipma boxes
+ skip_box_remain(&mut b)?;
+ let item_property = match other_box_type {
+ BoxType::AV1LayeredImageIndexingProperty => ItemProperty::LayeredImageIndexing,
+ BoxType::CleanApertureBox => ItemProperty::CleanAperture,
+ BoxType::LayerSelectorProperty => ItemProperty::LayerSelection,
+ BoxType::OperatingPointSelectorProperty => ItemProperty::OperatingPointSelector,
+ _ => {
+ warn!("No ItemProperty variant for {:?}", other_box_type);
+ ItemProperty::Unsupported(other_box_type)
+ }
+ };
+ debug!("Storing empty record {:?}", item_property);
+ item_property
+ }
+ };
+ properties.insert(index, property)?;
+
+ index = PropertyIndex(
+ index
+ .0
+ .checked_add(1) // must include ignored properties to have correct indexes
+ .ok_or_else(|| Error::from(Status::IpcoIndexOverflow))?,
+ );
+
+ check_parser_state!(b.content);
+ }
+
+ Ok(properties)
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ImageSpatialExtentsProperty {
+ image_width: u32,
+ image_height: u32,
+}
+
+/// Parse image spatial extents property
+///
+/// See HEIF (ISO 23008-12:2017) § 6.5.3.1
+fn read_ispe<T: Read>(src: &mut BMFFBox<T>) -> Result<ImageSpatialExtentsProperty> {
+ if read_fullbox_version_no_flags(src)? != 0 {
+ return Err(Error::Unsupported("ispe version"));
+ }
+
+ let image_width = be_u32(src)?;
+ let image_height = be_u32(src)?;
+
+ Ok(ImageSpatialExtentsProperty {
+ image_width,
+ image_height,
+ })
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct PixelAspectRatio {
+ h_spacing: u32,
+ v_spacing: u32,
+}
+
+/// Parse pixel aspect ratio property
+///
+/// See HEIF (ISO 23008-12:2017) § 6.5.4.1
+/// See ISOBMFF (ISO 14496-12:2020) § 12.1.4.2
+fn read_pasp<T: Read>(src: &mut BMFFBox<T>) -> Result<PixelAspectRatio> {
+ let h_spacing = be_u32(src)?;
+ let v_spacing = be_u32(src)?;
+
+ Ok(PixelAspectRatio {
+ h_spacing,
+ v_spacing,
+ })
+}
+
+#[derive(Debug)]
+pub struct PixelInformation {
+ bits_per_channel: TryVec<u8>,
+}
+
+/// Parse pixel information
+/// See HEIF (ISO 23008-12:2017) § 6.5.6
+fn read_pixi<T: Read>(src: &mut BMFFBox<T>) -> Result<PixelInformation> {
+ let version = read_fullbox_version_no_flags(src)?;
+ if version != 0 {
+ return Err(Error::Unsupported("pixi version"));
+ }
+
+ let num_channels = src.read_u8()?;
+ let mut bits_per_channel = TryVec::with_capacity(num_channels.to_usize())?;
+ let num_channels_read = src.try_read_to_end(&mut bits_per_channel)?;
+
+ if u8::try_from(num_channels_read)? != num_channels {
+ return Status::PixiBadChannelCount.into();
+ }
+
+ check_parser_state!(src.content);
+ Ok(PixelInformation { bits_per_channel })
+}
+
+/// Despite [Rec. ITU-T H.273] (12/2016) defining the CICP fields as having a
+/// range of 0-255, and only a small fraction of those values being used,
+/// ISOBMFF (ISO 14496-12:2020) § 12.1.5 defines them as 16-bit values in the
+/// `colr` box. Since we have no use for the additional range, and it would
+/// complicate matters later, we fallibly convert before storing the input.
+///
+/// [Rec. ITU-T H.273]: https://www.itu.int/rec/T-REC-H.273-201612-I/en
+#[repr(C)]
+#[derive(Debug)]
+pub struct NclxColourInformation {
+ colour_primaries: u8,
+ transfer_characteristics: u8,
+ matrix_coefficients: u8,
+ full_range_flag: bool,
+}
+
+/// The raw bytes of the ICC profile
+#[repr(C)]
+pub struct IccColourInformation {
+ bytes: TryVec<u8>,
+}
+
+impl fmt::Debug for IccColourInformation {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("IccColourInformation")
+ .field("data", &format_args!("{} bytes", self.bytes.len()))
+ .finish()
+ }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub enum ColourInformation {
+ Nclx(NclxColourInformation),
+ Icc(IccColourInformation, FourCC),
+}
+
+impl ColourInformation {
+ fn colour_type(&self) -> FourCC {
+ match self {
+ Self::Nclx(_) => FourCC::from(*b"nclx"),
+ Self::Icc(_, colour_type) => colour_type.clone(),
+ }
+ }
+}
+
+/// Parse colour information
+/// See ISOBMFF (ISO 14496-12:2020) § 12.1.5
+fn read_colr<T: Read>(
+ src: &mut BMFFBox<T>,
+ strictness: ParseStrictness,
+) -> Result<ColourInformation> {
+ let colour_type = be_u32(src)?.to_be_bytes();
+
+ match &colour_type {
+ b"nclx" => {
+ const NUM_RESERVED_BITS: u8 = 7;
+ let colour_primaries = be_u16(src)?.try_into()?;
+ let transfer_characteristics = be_u16(src)?.try_into()?;
+ let matrix_coefficients = be_u16(src)?.try_into()?;
+ let bytes = src.read_into_try_vec()?;
+ let mut bit_reader = BitReader::new(&bytes);
+ let full_range_flag = bit_reader.read_bool()?;
+ if bit_reader.remaining() != NUM_RESERVED_BITS.into() {
+ error!(
+ "read_colr expected {} reserved bits, found {}",
+ NUM_RESERVED_BITS,
+ bit_reader.remaining()
+ );
+ return Status::ColrBadSize.into();
+ }
+ if bit_reader.read_u8(NUM_RESERVED_BITS)? != 0 {
+ fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::ColrReservedNonzero,
+ )?;
+ }
+
+ Ok(ColourInformation::Nclx(NclxColourInformation {
+ colour_primaries,
+ transfer_characteristics,
+ matrix_coefficients,
+ full_range_flag,
+ }))
+ }
+ b"rICC" | b"prof" => Ok(ColourInformation::Icc(
+ IccColourInformation {
+ bytes: src.read_into_try_vec()?,
+ },
+ FourCC::from(colour_type),
+ )),
+ _ => {
+ error!("read_colr colour_type: {:?}", colour_type);
+ Status::ColrBadType.into()
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+/// Rotation in the positive (that is, anticlockwise) direction
+/// Visualized in terms of starting with (⥠) UPWARDS HARPOON WITH BARB LEFT FROM BAR
+/// similar to a DIGIT ONE (1)
+pub enum ImageRotation {
+ /// ⥠ UPWARDS HARPOON WITH BARB LEFT FROM BAR
+ D0,
+ /// ⥞ LEFTWARDS HARPOON WITH BARB DOWN FROM BAR
+ D90,
+ /// ⥝ DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR
+ D180,
+ /// ⥛ RIGHTWARDS HARPOON WITH BARB UP FROM BAR
+ D270,
+}
+
+/// Parse image rotation box
+/// See HEIF (ISO 23008-12:2017) § 6.5.10
+fn read_irot<T: Read>(src: &mut BMFFBox<T>) -> Result<ImageRotation> {
+ let irot = src.read_into_try_vec()?;
+ let mut irot = BitReader::new(&irot);
+ let _reserved = irot.read_u8(6)?;
+ let image_rotation = match irot.read_u8(2)? {
+ 0 => ImageRotation::D0,
+ 1 => ImageRotation::D90,
+ 2 => ImageRotation::D180,
+ 3 => ImageRotation::D270,
+ _ => unreachable!(),
+ };
+
+ check_parser_state!(src.content);
+
+ Ok(image_rotation)
+}
+
+/// The axis about which the image is mirrored (opposite of flip)
+/// Visualized in terms of starting with (⥠) UPWARDS HARPOON WITH BARB LEFT FROM BAR
+/// similar to a DIGIT ONE (1)
+#[repr(C)]
+#[derive(Debug)]
+pub enum ImageMirror {
+ /// top and bottom parts exchanged
+ /// ⥡ DOWNWARDS HARPOON WITH BARB LEFT FROM BAR
+ TopBottom,
+ /// left and right parts exchanged
+ /// ⥜ UPWARDS HARPOON WITH BARB RIGHT FROM BAR
+ LeftRight,
+}
+
+/// Parse image mirroring box
+/// See HEIF (ISO 23008-12:2017) § 6.5.12<br />
+/// Note: [ISO/IEC 23008-12:2017/DAmd 2](https://www.iso.org/standard/81688.html)
+/// reverses the interpretation of the 'imir' box in § 6.5.12.3:
+/// > `axis` specifies a vertical (`axis` = 0) or horizontal (`axis` = 1) axis
+/// > for the mirroring operation.
+///
+/// is replaced with:
+/// > `mode` specifies how the mirroring is performed: 0 indicates that the top
+/// > and bottom parts of the image are exchanged; 1 specifies that the left and
+/// > right parts are exchanged.
+/// >
+/// > NOTE: In Exif, orientation tag can be used to signal mirroring operations.
+/// > Exif orientation tag 4 corresponds to `mode` = 0 of `ImageMirror`, and
+/// > Exif orientation tag 2 corresponds to `mode` = 1 accordingly.
+///
+/// This implementation conforms to the text in Draft Amendment 2, which is the
+/// opposite of the published standard as of 4 June 2021.
+fn read_imir<T: Read>(src: &mut BMFFBox<T>) -> Result<ImageMirror> {
+ let imir = src.read_into_try_vec()?;
+ let mut imir = BitReader::new(&imir);
+ let _reserved = imir.read_u8(7)?;
+ let image_mirror = match imir.read_u8(1)? {
+ 0 => ImageMirror::TopBottom,
+ 1 => ImageMirror::LeftRight,
+ _ => unreachable!(),
+ };
+
+ check_parser_state!(src.content);
+
+ Ok(image_mirror)
+}
+
+/// See HEIF (ISO 23008-12:2017) § 6.5.8
+#[derive(Debug, PartialEq)]
+pub struct AuxiliaryTypeProperty {
+ aux_type: TryString,
+ aux_subtype: TryString,
+}
+
+/// Parse image properties for auxiliary images
+/// See HEIF (ISO 23008-12:2017) § 6.5.8
+fn read_auxc<T: Read>(src: &mut BMFFBox<T>) -> Result<AuxiliaryTypeProperty> {
+ let version = read_fullbox_version_no_flags(src)?;
+ if version != 0 {
+ return Err(Error::Unsupported("auxC version"));
+ }
+
+ let mut aux = TryString::new();
+ src.try_read_to_end(&mut aux)?;
+
+ let (aux_type, aux_subtype): (TryString, TryVec<u8>);
+ if let Some(nul_byte_pos) = aux.iter().position(|&b| b == b'\0') {
+ let (a, b) = aux.as_slice().split_at(nul_byte_pos);
+ aux_type = a.try_into()?;
+ aux_subtype = (b[1..]).try_into()?;
+ } else {
+ aux_type = aux;
+ aux_subtype = TryVec::new();
+ }
+
+ Ok(AuxiliaryTypeProperty {
+ aux_type,
+ aux_subtype,
+ })
+}
+
+/// Parse an item location box inside a meta box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.3
+fn read_iloc<T: Read>(src: &mut BMFFBox<T>) -> Result<TryHashMap<ItemId, ItemLocationBoxItem>> {
+ let version: IlocVersion = read_fullbox_version_no_flags(src)?.try_into()?;
+
+ let iloc = src.read_into_try_vec()?;
+ let mut iloc = BitReader::new(&iloc);
+
+ let offset_size: IlocFieldSize = iloc.read_u8(4)?.try_into()?;
+ let length_size: IlocFieldSize = iloc.read_u8(4)?.try_into()?;
+ let base_offset_size: IlocFieldSize = iloc.read_u8(4)?.try_into()?;
+
+ let index_size: Option<IlocFieldSize> = match version {
+ IlocVersion::One | IlocVersion::Two => Some(iloc.read_u8(4)?.try_into()?),
+ IlocVersion::Zero => {
+ let _reserved = iloc.read_u8(4)?;
+ None
+ }
+ };
+
+ let item_count = match version {
+ IlocVersion::Zero | IlocVersion::One => iloc.read_u32(16)?,
+ IlocVersion::Two => iloc.read_u32(32)?,
+ };
+
+ let mut items = TryHashMap::with_capacity(item_count.to_usize())?;
+
+ for _ in 0..item_count {
+ let item_id = ItemId(match version {
+ IlocVersion::Zero | IlocVersion::One => iloc.read_u32(16)?,
+ IlocVersion::Two => iloc.read_u32(32)?,
+ });
+
+ // The spec isn't entirely clear how an `iloc` should be interpreted for version 0,
+ // which has no `construction_method` field. It does say:
+ // "For maximum compatibility, version 0 of this box should be used in preference to
+ // version 1 with `construction_method==0`, or version 2 when possible."
+ // We take this to imply version 0 can be interpreted as using file offsets.
+ let construction_method = match version {
+ IlocVersion::Zero => ConstructionMethod::File,
+ IlocVersion::One | IlocVersion::Two => {
+ let _reserved = iloc.read_u16(12)?;
+ match iloc.read_u16(4)? {
+ 0 => ConstructionMethod::File,
+ 1 => ConstructionMethod::Idat,
+ 2 => ConstructionMethod::Item,
+ _ => return Status::IlocBadConstructionMethod.into(),
+ }
+ }
+ };
+
+ let data_reference_index = iloc.read_u16(16)?;
+ if data_reference_index != 0 {
+ return Err(Error::Unsupported(
+ "external file references (iloc.data_reference_index != 0) are not supported",
+ ));
+ }
+ let base_offset = iloc.read_u64(base_offset_size.as_bits())?;
+ let extent_count = iloc.read_u16(16)?;
+
+ if extent_count < 1 {
+ return Status::IlocBadExtentCount.into();
+ }
+
+ // "If only one extent is used (extent_count = 1) then either or both of the
+ // offset and length may be implied"
+ if extent_count != 1
+ && (offset_size == IlocFieldSize::Zero || length_size == IlocFieldSize::Zero)
+ {
+ return Status::IlocBadExtent.into();
+ }
+
+ let mut extents = TryVec::with_capacity(extent_count.to_usize())?;
+
+ for _ in 0..extent_count {
+ // Parsed but currently ignored, see `Extent`
+ let _extent_index = match &index_size {
+ None | Some(IlocFieldSize::Zero) => None,
+ Some(index_size) => {
+ debug_assert!(version == IlocVersion::One || version == IlocVersion::Two);
+ Some(iloc.read_u64(index_size.as_bits())?)
+ }
+ };
+
+ // Per ISOBMFF (ISO 14496-12:2020) § 8.11.3.1:
+ // "If the offset is not identified (the field has a length of zero), then the
+ // beginning of the source (offset 0) is implied"
+ // This behavior will follow from BitReader::read_u64(0) -> 0.
+ let extent_offset = iloc.read_u64(offset_size.as_bits())?;
+ let extent_length = iloc.read_u64(length_size.as_bits())?.try_into()?;
+
+ // "If the length is not specified, or specified as zero, then the entire length of
+ // the source is implied" (ibid)
+ let offset = base_offset
+ .checked_add(extent_offset)
+ .ok_or_else(|| Error::from(Status::IlocOffsetOverflow))?;
+ let extent = if extent_length == 0 {
+ Extent::ToEnd { offset }
+ } else {
+ Extent::WithLength {
+ offset,
+ len: extent_length,
+ }
+ };
+
+ extents.push(extent)?;
+ }
+
+ let loc = ItemLocationBoxItem {
+ construction_method,
+ extents,
+ };
+
+ if items.insert(item_id, loc)?.is_some() {
+ return Status::IlocDuplicateItemId.into();
+ }
+ }
+
+ if iloc.remaining() == 0 {
+ Ok(items)
+ } else {
+ Status::IlocBadSize.into()
+ }
+}
+
+/// Read the contents of a box, including sub boxes.
+pub fn read_mp4<T: Read>(f: &mut T) -> Result<MediaContext> {
+ let mut context = None;
+ let mut found_ftyp = false;
+ // TODO(kinetik): Top-level parsing should handle zero-sized boxes
+ // rather than throwing an error.
+ let mut iter = BoxIter::new(f);
+ while let Some(mut b) = iter.next_box()? {
+ // box ordering: ftyp before any variable length box (inc. moov),
+ // but may not be first box in file if file signatures etc. present
+ // fragmented mp4 order: ftyp, moov, pairs of moof/mdat (1-multiple), mfra
+
+ // "special": uuid, wide (= 8 bytes)
+ // isom: moov, mdat, free, skip, udta, ftyp, moof, mfra
+ // iso2: pdin, meta
+ // iso3: meco
+ // iso5: styp, sidx, ssix, prft
+ // unknown, maybe: id32
+
+ // qt: pnot
+
+ // possibly allow anything where all printable and/or all lowercase printable
+ // "four printable characters from the ISO 8859-1 character set"
+ match b.head.name {
+ BoxType::FileTypeBox => {
+ let ftyp = read_ftyp(&mut b)?;
+ found_ftyp = true;
+ debug!("{:?}", ftyp);
+ }
+ BoxType::MovieBox => {
+ context = Some(read_moov(&mut b, context)?);
+ }
+ #[cfg(feature = "meta-xml")]
+ BoxType::MetadataBox => {
+ if let Some(ctx) = &mut context {
+ ctx.metadata = Some(read_meta(&mut b));
+ }
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ if context.is_some() {
+ debug!(
+ "found moov {}, could stop pure 'moov' parser now",
+ if found_ftyp {
+ "and ftyp"
+ } else {
+ "but no ftyp"
+ }
+ );
+ }
+ }
+
+ // XXX(kinetik): This isn't perfect, as a "moov" with no contents is
+ // treated as okay but we haven't found anything useful. Needs more
+ // thought for clearer behaviour here.
+ context.ok_or(Error::MoovMissing)
+}
+
+/// Parse a Movie Header Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.2.2
+fn parse_mvhd<T: Read>(f: &mut BMFFBox<T>) -> Result<Option<MediaTimeScale>> {
+ let mvhd = read_mvhd(f)?;
+ debug!("{:?}", mvhd);
+ if mvhd.timescale == 0 {
+ return Status::MvhdBadTimescale.into();
+ }
+ let timescale = Some(MediaTimeScale(u64::from(mvhd.timescale)));
+ Ok(timescale)
+}
+
+/// Parse a Movie Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.2.1
+/// Note that despite the spec indicating "exactly one" moov box should exist at
+/// the file container level, we support reading and merging multiple moov boxes
+/// such as with tests/test_case_1185230.mp4.
+fn read_moov<T: Read>(f: &mut BMFFBox<T>, context: Option<MediaContext>) -> Result<MediaContext> {
+ let MediaContext {
+ mut timescale,
+ mut tracks,
+ mut mvex,
+ mut psshs,
+ mut userdata,
+ #[cfg(feature = "meta-xml")]
+ metadata,
+ } = context.unwrap_or_default();
+
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MovieHeaderBox => {
+ timescale = parse_mvhd(&mut b)?;
+ }
+ BoxType::TrackBox => {
+ let mut track = Track::new(tracks.len());
+ read_trak(&mut b, &mut track)?;
+ tracks.push(track)?;
+ }
+ BoxType::MovieExtendsBox => {
+ mvex = Some(read_mvex(&mut b)?);
+ debug!("{:?}", mvex);
+ }
+ BoxType::ProtectionSystemSpecificHeaderBox => {
+ let pssh = read_pssh(&mut b)?;
+ debug!("{:?}", pssh);
+ psshs.push(pssh)?;
+ }
+ BoxType::UserdataBox => {
+ userdata = Some(read_udta(&mut b));
+ debug!("{:?}", userdata);
+ if let Some(Err(_)) = userdata {
+ // There was an error parsing userdata. Such failures are not fatal to overall
+ // parsing, just skip the rest of the box.
+ skip_box_remain(&mut b)?;
+ }
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+
+ Ok(MediaContext {
+ timescale,
+ tracks,
+ mvex,
+ psshs,
+ userdata,
+ #[cfg(feature = "meta-xml")]
+ metadata,
+ })
+}
+
+fn read_pssh<T: Read>(src: &mut BMFFBox<T>) -> Result<ProtectionSystemSpecificHeaderBox> {
+ let len = src.bytes_left();
+ let mut box_content = read_buf(src, len)?;
+ let (system_id, kid, data) = {
+ let pssh = &mut Cursor::new(&box_content);
+
+ let (version, _) = read_fullbox_extra(pssh)?;
+
+ let system_id = read_buf(pssh, 16)?;
+
+ let mut kid = TryVec::<ByteData>::new();
+ if version > 0 {
+ const KID_ELEMENT_SIZE: usize = 16;
+ let count = be_u32(pssh)?.to_usize();
+ kid.reserve(
+ count
+ .checked_mul(KID_ELEMENT_SIZE)
+ .ok_or_else(|| Error::from(Status::PsshSizeOverflow))?,
+ )?;
+ for _ in 0..count {
+ let item = read_buf(pssh, KID_ELEMENT_SIZE.to_u64())?;
+ kid.push(item)?;
+ }
+ }
+
+ let data_size = be_u32(pssh)?;
+ let data = read_buf(pssh, data_size.into())?;
+
+ (system_id, kid, data)
+ };
+
+ let mut pssh_box = TryVec::new();
+ write_be_u32(&mut pssh_box, src.head.size.try_into()?)?;
+ pssh_box.extend_from_slice(b"pssh")?;
+ pssh_box.append(&mut box_content)?;
+
+ Ok(ProtectionSystemSpecificHeaderBox {
+ system_id,
+ kid,
+ data,
+ box_content: pssh_box,
+ })
+}
+
+/// Parse a Movie Extends Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.8.1
+fn read_mvex<T: Read>(src: &mut BMFFBox<T>) -> Result<MovieExtendsBox> {
+ let mut iter = src.box_iter();
+ let mut fragment_duration = None;
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MovieExtendsHeaderBox => {
+ let duration = read_mehd(&mut b)?;
+ fragment_duration = Some(duration);
+ }
+ _ => skip_box_content(&mut b)?,
+ }
+ }
+ Ok(MovieExtendsBox { fragment_duration })
+}
+
+fn read_mehd<T: Read>(src: &mut BMFFBox<T>) -> Result<MediaScaledTime> {
+ let (version, _) = read_fullbox_extra(src)?;
+ let fragment_duration = match version {
+ 1 => be_u64(src)?,
+ 0 => u64::from(be_u32(src)?),
+ _ => return Status::MehdBadVersion.into(),
+ };
+ Ok(MediaScaledTime(fragment_duration))
+}
+
+/// Parse a Track Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.3.1.
+fn read_trak<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::TrackHeaderBox => {
+ let tkhd = read_tkhd(&mut b)?;
+ track.track_id = Some(tkhd.track_id);
+ track.tkhd = Some(tkhd.clone());
+ debug!("{:?}", tkhd);
+ }
+ BoxType::EditBox => read_edts(&mut b, track)?,
+ BoxType::MediaBox => read_mdia(&mut b, track)?,
+ BoxType::TrackReferenceBox => track.tref = Some(read_tref(&mut b)?),
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+fn read_edts<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::EditListBox => {
+ let elst = read_elst(&mut b)?;
+ track.looped = Some(elst.looped);
+ if elst.edits.is_empty() {
+ debug!("empty edit list");
+ continue;
+ }
+ let mut empty_duration = 0;
+ let mut idx = 0;
+ if elst.edits[idx].media_time == -1 {
+ if elst.edits.len() < 2 {
+ debug!("expected additional edit, ignoring edit list");
+ continue;
+ }
+ empty_duration = elst.edits[idx].segment_duration;
+ idx += 1;
+ }
+ track.empty_duration = Some(MediaScaledTime(empty_duration));
+ let media_time = elst.edits[idx].media_time;
+ if media_time < 0 {
+ debug!("unexpected negative media time in edit");
+ }
+ track.edited_duration = Some(MediaScaledTime(elst.edits[idx].segment_duration));
+ track.media_time = Some(TrackScaledTime::<u64>(
+ std::cmp::max(0, media_time) as u64,
+ track.id,
+ ));
+ if elst.edits.len() > 2 {
+ debug!("ignoring edit list with {} entries", elst.edits.len());
+ }
+ debug!("{:?}", elst);
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+#[allow(clippy::type_complexity)] // Allow the complex return, maybe rework in future
+fn parse_mdhd<T: Read>(
+ f: &mut BMFFBox<T>,
+ track: &Track,
+) -> Result<(
+ MediaHeaderBox,
+ Option<TrackScaledTime<u64>>,
+ Option<TrackTimeScale<u64>>,
+)> {
+ let mdhd = read_mdhd(f)?;
+ let duration = match mdhd.duration {
+ std::u64::MAX => None,
+ duration => Some(TrackScaledTime::<u64>(duration, track.id)),
+ };
+ if mdhd.timescale == 0 {
+ return Status::MdhdBadTimescale.into();
+ }
+ let timescale = Some(TrackTimeScale::<u64>(u64::from(mdhd.timescale), track.id));
+ Ok((mdhd, duration, timescale))
+}
+
+fn read_mdia<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MediaHeaderBox => {
+ let (mdhd, duration, timescale) = parse_mdhd(&mut b, track)?;
+ track.duration = duration;
+ track.timescale = timescale;
+ debug!("{:?}", mdhd);
+ }
+ BoxType::HandlerBox => {
+ let hdlr = read_hdlr(&mut b, ParseStrictness::Permissive)?;
+
+ match hdlr.handler_type.value.as_ref() {
+ b"vide" => track.track_type = TrackType::Video,
+ b"pict" => track.track_type = TrackType::Picture,
+ b"auxv" => track.track_type = TrackType::AuxiliaryVideo,
+ b"soun" => track.track_type = TrackType::Audio,
+ b"meta" => track.track_type = TrackType::Metadata,
+ _ => (),
+ }
+ debug!("{:?}", hdlr);
+ }
+ BoxType::MediaInformationBox => read_minf(&mut b, track)?,
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+fn read_tref<T: Read>(f: &mut BMFFBox<T>) -> Result<TrackReferenceBox> {
+ // Will likely only see trefs with one auxl
+ let mut references = TryVec::with_capacity(1)?;
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::AuxiliaryBox => {
+ references.push(TrackReferenceEntry::Auxiliary(read_tref_auxl(&mut b)?))?
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(TrackReferenceBox { references })
+}
+
+fn read_tref_auxl<T: Read>(f: &mut BMFFBox<T>) -> Result<TrackReference> {
+ let num_track_ids = (f.bytes_left() / std::mem::size_of::<u32>().to_u64()).try_into()?;
+ let mut track_ids = TryVec::with_capacity(num_track_ids)?;
+ for _ in 0..num_track_ids {
+ track_ids.push(be_u32(f)?)?;
+ }
+
+ Ok(TrackReference { track_ids })
+}
+
+fn read_minf<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::SampleTableBox => read_stbl(&mut b, track)?,
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+fn read_stbl<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
+ let mut iter = f.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::SampleDescriptionBox => {
+ let stsd = read_stsd(&mut b, track)?;
+ debug!("{:?}", stsd);
+ track.stsd = Some(stsd);
+ }
+ BoxType::TimeToSampleBox => {
+ let stts = read_stts(&mut b)?;
+ debug!("{:?}", stts);
+ track.stts = Some(stts);
+ }
+ BoxType::SampleToChunkBox => {
+ let stsc = read_stsc(&mut b)?;
+ debug!("{:?}", stsc);
+ track.stsc = Some(stsc);
+ }
+ BoxType::SampleSizeBox => {
+ let stsz = read_stsz(&mut b)?;
+ debug!("{:?}", stsz);
+ track.stsz = Some(stsz);
+ }
+ BoxType::ChunkOffsetBox => {
+ let stco = read_stco(&mut b)?;
+ debug!("{:?}", stco);
+ track.stco = Some(stco);
+ }
+ BoxType::ChunkLargeOffsetBox => {
+ let co64 = read_co64(&mut b)?;
+ debug!("{:?}", co64);
+ track.stco = Some(co64);
+ }
+ BoxType::SyncSampleBox => {
+ let stss = read_stss(&mut b)?;
+ debug!("{:?}", stss);
+ track.stss = Some(stss);
+ }
+ BoxType::CompositionOffsetBox => {
+ let ctts = read_ctts(&mut b)?;
+ debug!("{:?}", ctts);
+ track.ctts = Some(ctts);
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+/// Parse an ftyp box.
+/// See ISOBMFF (ISO 14496-12:2020) § 4.3
+fn read_ftyp<T: Read>(src: &mut BMFFBox<T>) -> Result<FileTypeBox> {
+ let major = be_u32(src)?;
+ let minor = be_u32(src)?;
+ let bytes_left = src.bytes_left();
+ if bytes_left % 4 != 0 {
+ return Status::FtypBadSize.into();
+ }
+ // Is a brand_count of zero valid?
+ let brand_count = bytes_left / 4;
+ let mut brands = TryVec::with_capacity(brand_count.try_into()?)?;
+ for _ in 0..brand_count {
+ brands.push(be_u32(src)?.into())?;
+ }
+ Ok(FileTypeBox {
+ major_brand: From::from(major),
+ minor_version: minor,
+ compatible_brands: brands,
+ })
+}
+
+/// Parse an mvhd box.
+fn read_mvhd<T: Read>(src: &mut BMFFBox<T>) -> Result<MovieHeaderBox> {
+ let (version, _) = read_fullbox_extra(src)?;
+ match version {
+ // 64 bit creation and modification times.
+ 1 => {
+ skip(src, 16)?;
+ }
+ // 32 bit creation and modification times.
+ 0 => {
+ skip(src, 8)?;
+ }
+ _ => return Status::MvhdBadVersion.into(),
+ }
+ let timescale = be_u32(src)?;
+ let duration = match version {
+ 1 => be_u64(src)?,
+ 0 => {
+ let d = be_u32(src)?;
+ if d == std::u32::MAX {
+ std::u64::MAX
+ } else {
+ u64::from(d)
+ }
+ }
+ _ => unreachable!("Should have returned Status::MvhdBadVersion"),
+ };
+ // Skip remaining valid fields.
+ skip(src, 80)?;
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+ Ok(MovieHeaderBox {
+ timescale,
+ duration,
+ })
+}
+
+/// Parse a tkhd box.
+fn read_tkhd<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackHeaderBox> {
+ let (version, flags) = read_fullbox_extra(src)?;
+ let disabled = flags & 0x1u32 == 0 || flags & 0x2u32 == 0;
+ match version {
+ // 64 bit creation and modification times.
+ 1 => {
+ skip(src, 16)?;
+ }
+ // 32 bit creation and modification times.
+ 0 => {
+ skip(src, 8)?;
+ }
+ _ => return Status::TkhdBadVersion.into(),
+ }
+ let track_id = be_u32(src)?;
+ skip(src, 4)?;
+ let duration = match version {
+ 1 => be_u64(src)?,
+ 0 => u64::from(be_u32(src)?),
+ _ => unreachable!("Should have returned Status::TkhdBadVersion"),
+ };
+ // Skip uninteresting fields.
+ skip(src, 16)?;
+
+ let matrix = Matrix {
+ a: be_i32(src)?,
+ b: be_i32(src)?,
+ u: be_i32(src)?,
+ c: be_i32(src)?,
+ d: be_i32(src)?,
+ v: be_i32(src)?,
+ x: be_i32(src)?,
+ y: be_i32(src)?,
+ w: be_i32(src)?,
+ };
+
+ let width = be_u32(src)?;
+ let height = be_u32(src)?;
+ Ok(TrackHeaderBox {
+ track_id,
+ disabled,
+ duration,
+ width,
+ height,
+ matrix,
+ })
+}
+
+/// Parse a elst box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.6.6
+fn read_elst<T: Read>(src: &mut BMFFBox<T>) -> Result<EditListBox> {
+ let (version, flags) = read_fullbox_extra(src)?;
+ let edit_count = be_u32(src)?;
+ let mut edits = TryVec::with_capacity(edit_count.to_usize())?;
+ for _ in 0..edit_count {
+ let (segment_duration, media_time) = match version {
+ 1 => {
+ // 64 bit segment duration and media times.
+ (be_u64(src)?, be_i64(src)?)
+ }
+ 0 => {
+ // 32 bit segment duration and media times.
+ (u64::from(be_u32(src)?), i64::from(be_i32(src)?))
+ }
+ _ => return Status::ElstBadVersion.into(),
+ };
+ let media_rate_integer = be_i16(src)?;
+ let media_rate_fraction = be_i16(src)?;
+ edits.push(Edit {
+ segment_duration,
+ media_time,
+ media_rate_integer,
+ media_rate_fraction,
+ })?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(EditListBox {
+ looped: flags == 1,
+ edits,
+ })
+}
+
+/// Parse a mdhd box.
+fn read_mdhd<T: Read>(src: &mut BMFFBox<T>) -> Result<MediaHeaderBox> {
+ let (version, _) = read_fullbox_extra(src)?;
+ let (timescale, duration) = match version {
+ 1 => {
+ // Skip 64-bit creation and modification times.
+ skip(src, 16)?;
+
+ // 64 bit duration.
+ (be_u32(src)?, be_u64(src)?)
+ }
+ 0 => {
+ // Skip 32-bit creation and modification times.
+ skip(src, 8)?;
+
+ // 32 bit duration.
+ let timescale = be_u32(src)?;
+ let duration = {
+ // Since we convert the 32-bit duration to 64-bit by
+ // upcasting, we need to preserve the special all-1s
+ // ("unknown") case by hand.
+ let d = be_u32(src)?;
+ if d == std::u32::MAX {
+ std::u64::MAX
+ } else {
+ u64::from(d)
+ }
+ };
+ (timescale, duration)
+ }
+ _ => return Status::MdhdBadVersion.into(),
+ };
+
+ // Skip uninteresting fields.
+ skip(src, 4)?;
+
+ Ok(MediaHeaderBox {
+ timescale,
+ duration,
+ })
+}
+
+/// Parse a stco box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.7.5
+fn read_stco<T: Read>(src: &mut BMFFBox<T>) -> Result<ChunkOffsetBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let offset_count = be_u32(src)?;
+ let mut offsets = TryVec::with_capacity(offset_count.to_usize())?;
+ for _ in 0..offset_count {
+ offsets.push(be_u32(src)?.into())?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(ChunkOffsetBox { offsets })
+}
+
+/// Parse a co64 box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.7.5
+fn read_co64<T: Read>(src: &mut BMFFBox<T>) -> Result<ChunkOffsetBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let offset_count = be_u32(src)?;
+ let mut offsets = TryVec::with_capacity(offset_count.to_usize())?;
+ for _ in 0..offset_count {
+ offsets.push(be_u64(src)?)?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(ChunkOffsetBox { offsets })
+}
+
+/// Parse a stss box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.6.2
+fn read_stss<T: Read>(src: &mut BMFFBox<T>) -> Result<SyncSampleBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let sample_count = be_u32(src)?;
+ let mut samples = TryVec::with_capacity(sample_count.to_usize())?;
+ for _ in 0..sample_count {
+ samples.push(be_u32(src)?)?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(SyncSampleBox { samples })
+}
+
+/// Parse a stsc box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.7.4
+fn read_stsc<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleToChunkBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let sample_count = be_u32(src)?;
+ let mut samples = TryVec::with_capacity(sample_count.to_usize())?;
+ for _ in 0..sample_count {
+ let first_chunk = be_u32(src)?;
+ let samples_per_chunk = be_u32(src)?;
+ let sample_description_index = be_u32(src)?;
+ samples.push(SampleToChunk {
+ first_chunk,
+ samples_per_chunk,
+ sample_description_index,
+ })?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(SampleToChunkBox { samples })
+}
+
+/// Parse a Composition Time to Sample Box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.6.1.3
+fn read_ctts<T: Read>(src: &mut BMFFBox<T>) -> Result<CompositionOffsetBox> {
+ let (version, _) = read_fullbox_extra(src)?;
+
+ let counts = be_u32(src)?;
+
+ if counts
+ .checked_mul(8)
+ .map_or(true, |bytes| u64::from(bytes) > src.bytes_left())
+ {
+ return Status::CttsBadSize.into();
+ }
+
+ let mut offsets = TryVec::with_capacity(counts.to_usize())?;
+ for _ in 0..counts {
+ let (sample_count, time_offset) = match version {
+ // According to spec, Version0 shoule be used when version == 0;
+ // however, some buggy contents have negative value when version == 0.
+ // So we always use Version1 here.
+ 0..=1 => {
+ let count = be_u32(src)?;
+ let offset = TimeOffsetVersion::Version1(be_i32(src)?);
+ (count, offset)
+ }
+ _ => {
+ return Status::CttsBadVersion.into();
+ }
+ };
+ offsets.push(TimeOffset {
+ sample_count,
+ time_offset,
+ })?;
+ }
+
+ check_parser_state!(src.content);
+
+ Ok(CompositionOffsetBox { samples: offsets })
+}
+
+/// Parse a stsz box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.7.3.2
+fn read_stsz<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleSizeBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let sample_size = be_u32(src)?;
+ let sample_count = be_u32(src)?;
+ let mut sample_sizes = TryVec::new();
+ if sample_size == 0 {
+ sample_sizes.reserve(sample_count.to_usize())?;
+ for _ in 0..sample_count {
+ sample_sizes.push(be_u32(src)?)?;
+ }
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(SampleSizeBox {
+ sample_size,
+ sample_sizes,
+ })
+}
+
+/// Parse a stts box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.6.1.2
+fn read_stts<T: Read>(src: &mut BMFFBox<T>) -> Result<TimeToSampleBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let sample_count = be_u32(src)?;
+ let mut samples = TryVec::with_capacity(sample_count.to_usize())?;
+ for _ in 0..sample_count {
+ let sample_count = be_u32(src)?;
+ let sample_delta = be_u32(src)?;
+ samples.push(Sample {
+ sample_count,
+ sample_delta,
+ })?;
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(TimeToSampleBox { samples })
+}
+
+/// Parse a VPx Config Box.
+fn read_vpcc<T: Read>(src: &mut BMFFBox<T>) -> Result<VPxConfigBox> {
+ let (version, _) = read_fullbox_extra(src)?;
+ let supported_versions = [0, 1];
+ if !supported_versions.contains(&version) {
+ return Err(Error::Unsupported("unknown vpcC version"));
+ }
+
+ let profile = src.read_u8()?;
+ let level = src.read_u8()?;
+ let (
+ bit_depth,
+ colour_primaries,
+ chroma_subsampling,
+ transfer_characteristics,
+ matrix_coefficients,
+ video_full_range_flag,
+ ) = if version == 0 {
+ let (bit_depth, colour_primaries) = {
+ let byte = src.read_u8()?;
+ ((byte >> 4) & 0x0f, byte & 0x0f)
+ };
+ // Note, transfer_characteristics was known as transfer_function in v0
+ let (chroma_subsampling, transfer_characteristics, video_full_range_flag) = {
+ let byte = src.read_u8()?;
+ ((byte >> 4) & 0x0f, (byte >> 1) & 0x07, (byte & 1) == 1)
+ };
+ (
+ bit_depth,
+ colour_primaries,
+ chroma_subsampling,
+ transfer_characteristics,
+ None,
+ video_full_range_flag,
+ )
+ } else {
+ let (bit_depth, chroma_subsampling, video_full_range_flag) = {
+ let byte = src.read_u8()?;
+ ((byte >> 4) & 0x0f, (byte >> 1) & 0x07, (byte & 1) == 1)
+ };
+ let colour_primaries = src.read_u8()?;
+ let transfer_characteristics = src.read_u8()?;
+ let matrix_coefficients = src.read_u8()?;
+
+ (
+ bit_depth,
+ colour_primaries,
+ chroma_subsampling,
+ transfer_characteristics,
+ Some(matrix_coefficients),
+ video_full_range_flag,
+ )
+ };
+
+ let codec_init_size = be_u16(src)?;
+ let codec_init = read_buf(src, codec_init_size.into())?;
+
+ // TODO(rillian): validate field value ranges.
+ Ok(VPxConfigBox {
+ profile,
+ level,
+ bit_depth,
+ colour_primaries,
+ chroma_subsampling,
+ transfer_characteristics,
+ matrix_coefficients,
+ video_full_range_flag,
+ codec_init,
+ })
+}
+
+/// See [AV1-ISOBMFF § 2.3.3](https://aomediacodec.github.io/av1-isobmff/#av1codecconfigurationbox-syntax)
+fn read_av1c<T: Read>(src: &mut BMFFBox<T>) -> Result<AV1ConfigBox> {
+ // We want to store the raw config as well as a structured (parsed) config, so create a copy of
+ // the raw config so we have it later, and then parse the structured data from that.
+ let raw_config = src.read_into_try_vec()?;
+ let mut raw_config_slice = raw_config.as_slice();
+ let marker_byte = raw_config_slice.read_u8()?;
+ if marker_byte & 0x80 != 0x80 {
+ return Err(Error::Unsupported("missing av1C marker bit"));
+ }
+ if marker_byte & 0x7f != 0x01 {
+ return Err(Error::Unsupported("missing av1C marker bit"));
+ }
+ let profile_byte = raw_config_slice.read_u8()?;
+ let profile = (profile_byte & 0xe0) >> 5;
+ let level = profile_byte & 0x1f;
+ let flags_byte = raw_config_slice.read_u8()?;
+ let tier = (flags_byte & 0x80) >> 7;
+ let bit_depth = match flags_byte & 0x60 {
+ 0x60 => 12,
+ 0x40 => 10,
+ _ => 8,
+ };
+ let monochrome = flags_byte & 0x10 == 0x10;
+ let chroma_subsampling_x = (flags_byte & 0x08) >> 3;
+ let chroma_subsampling_y = (flags_byte & 0x04) >> 2;
+ let chroma_sample_position = flags_byte & 0x03;
+ let delay_byte = raw_config_slice.read_u8()?;
+ let initial_presentation_delay_present = (delay_byte & 0x10) == 0x10;
+ let initial_presentation_delay_minus_one = if initial_presentation_delay_present {
+ delay_byte & 0x0f
+ } else {
+ 0
+ };
+
+ Ok(AV1ConfigBox {
+ profile,
+ level,
+ tier,
+ bit_depth,
+ monochrome,
+ chroma_subsampling_x,
+ chroma_subsampling_y,
+ chroma_sample_position,
+ initial_presentation_delay_present,
+ initial_presentation_delay_minus_one,
+ raw_config,
+ })
+}
+
+fn read_flac_metadata<T: Read>(src: &mut BMFFBox<T>) -> Result<FLACMetadataBlock> {
+ let temp = src.read_u8()?;
+ let block_type = temp & 0x7f;
+ let length = be_u24(src)?.into();
+ if length > src.bytes_left() {
+ return Status::DflaBadMetadataBlockSize.into();
+ }
+ let data = read_buf(src, length)?;
+ Ok(FLACMetadataBlock { block_type, data })
+}
+
+/// See MPEG-4 Systems (ISO 14496-1:2010) § 7.2.6.5
+fn find_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
+ // Tags for elementary stream description
+ const ESDESCR_TAG: u8 = 0x03;
+ const DECODER_CONFIG_TAG: u8 = 0x04;
+ const DECODER_SPECIFIC_TAG: u8 = 0x05;
+
+ let mut remains = data;
+
+ // Descriptor length should be more than 2 bytes.
+ while remains.len() > 2 {
+ let des = &mut Cursor::new(remains);
+ let tag = des.read_u8()?;
+
+ // See MPEG-4 Systems (ISO 14496-1:2010) § 8.3.3 for interpreting size of expandable classes
+
+ let mut end: u32 = 0; // It's u8 without declaration type that is incorrect.
+ // MSB of extend_or_len indicates more bytes, up to 4 bytes.
+ for _ in 0..4 {
+ if des.position() == remains.len().to_u64() {
+ // There's nothing more to read, the 0x80 was actually part of
+ // the content, and not an extension size.
+ end = des.position() as u32;
+ break;
+ }
+ let extend_or_len = des.read_u8()?;
+ end = (end << 7) + u32::from(extend_or_len & 0x7F);
+ if (extend_or_len & 0b1000_0000) == 0 {
+ end += des.position() as u32;
+ break;
+ }
+ }
+
+ if end.to_usize() > remains.len() || u64::from(end) < des.position() {
+ return Status::EsdsBadDescriptor.into();
+ }
+
+ let descriptor = &remains[des.position().try_into()?..end.to_usize()];
+
+ match tag {
+ ESDESCR_TAG => {
+ read_es_descriptor(descriptor, esds)?;
+ }
+ DECODER_CONFIG_TAG => {
+ read_dc_descriptor(descriptor, esds)?;
+ }
+ DECODER_SPECIFIC_TAG => {
+ read_ds_descriptor(descriptor, esds)?;
+ }
+ _ => {
+ debug!("Unsupported descriptor, tag {}", tag);
+ }
+ }
+
+ remains = &remains[end.to_usize()..remains.len()];
+ debug!("remains.len(): {}", remains.len());
+ }
+
+ Ok(())
+}
+
+fn get_audio_object_type(bit_reader: &mut BitReader) -> Result<u16> {
+ let mut audio_object_type: u16 = ReadInto::read(bit_reader, 5)?;
+
+ // Extend audio object type, for example, HE-AAC.
+ if audio_object_type == 31 {
+ let audio_object_type_ext: u16 = ReadInto::read(bit_reader, 6)?;
+ audio_object_type = 32 + audio_object_type_ext;
+ }
+ Ok(audio_object_type)
+}
+
+/// See MPEG-4 Systems (ISO 14496-1:2010) § 7.2.6.7 and probably 14496-3 somewhere?
+fn read_ds_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
+ #[cfg(feature = "mp4v")]
+ // Check if we are in a Visual esda Box.
+ if esds.video_codec != CodecType::Unknown {
+ esds.decoder_specific_data.extend_from_slice(data)?;
+ return Ok(());
+ }
+
+ // We are in an Audio esda Box.
+ let frequency_table = [
+ (0x0, 96000),
+ (0x1, 88200),
+ (0x2, 64000),
+ (0x3, 48000),
+ (0x4, 44100),
+ (0x5, 32000),
+ (0x6, 24000),
+ (0x7, 22050),
+ (0x8, 16000),
+ (0x9, 12000),
+ (0xa, 11025),
+ (0xb, 8000),
+ (0xc, 7350),
+ ];
+
+ let bit_reader = &mut BitReader::new(data);
+
+ let mut audio_object_type = get_audio_object_type(bit_reader)?;
+
+ let sample_index: u32 = ReadInto::read(bit_reader, 4)?;
+
+ // Sample frequency could be from table, or retrieved from stream directly
+ // if index is 0x0f.
+ let sample_frequency = match sample_index {
+ 0x0F => Some(ReadInto::read(bit_reader, 24)?),
+ _ => frequency_table
+ .iter()
+ .find(|item| item.0 == sample_index)
+ .map(|x| x.1),
+ };
+
+ let channel_configuration: u16 = ReadInto::read(bit_reader, 4)?;
+
+ let extended_audio_object_type = match audio_object_type {
+ 5 | 29 => Some(5),
+ _ => None,
+ };
+
+ if audio_object_type == 5 || audio_object_type == 29 {
+ // We have an explicit signaling for BSAC extension, should the decoder
+ // decode the BSAC extension (all Gecko's AAC decoders do), then this is
+ // what the stream will actually look like once decoded.
+ let _extended_sample_index = ReadInto::read(bit_reader, 4)?;
+ let _extended_sample_frequency: Option<u32> = match _extended_sample_index {
+ 0x0F => Some(ReadInto::read(bit_reader, 24)?),
+ _ => frequency_table
+ .iter()
+ .find(|item| item.0 == sample_index)
+ .map(|x| x.1),
+ };
+ audio_object_type = get_audio_object_type(bit_reader)?;
+ let _extended_channel_configuration = match audio_object_type {
+ 22 => ReadInto::read(bit_reader, 4)?,
+ _ => channel_configuration,
+ };
+ };
+
+ match audio_object_type {
+ 1..=4 | 6 | 7 | 17 | 19..=23 => {
+ if sample_frequency.is_none() {
+ return Err(Error::Unsupported("unknown frequency"));
+ }
+
+ // parsing GASpecificConfig
+
+ // If the sampling rate is not one of the rates listed in the right
+ // column in Table 4.82, the sampling frequency dependent tables
+ // (code tables, scale factor band tables etc.) must be deduced in
+ // order for the bitstream payload to be parsed. Since a given
+ // sampling frequency is associated with only one sampling frequency
+ // table, and since maximum flexibility is desired in the range of
+ // possible sampling frequencies, the following table shall be used
+ // to associate an implied sampling frequency with the desired
+ // sampling frequency dependent tables.
+ let sample_frequency_value = match sample_frequency.unwrap() {
+ 0..=9390 => 8000,
+ 9391..=11501 => 11025,
+ 11502..=13855 => 12000,
+ 13856..=18782 => 16000,
+ 18783..=23003 => 22050,
+ 23004..=27712 => 24000,
+ 27713..=37565 => 32000,
+ 37566..=46008 => 44100,
+ 46009..=55425 => 48000,
+ 55426..=75131 => 64000,
+ 75132..=92016 => 88200,
+ _ => 96000,
+ };
+
+ bit_reader.skip(1)?; // frameLengthFlag
+ let depend_on_core_order: u8 = ReadInto::read(bit_reader, 1)?;
+ if depend_on_core_order > 0 {
+ bit_reader.skip(14)?; // codeCoderDelay
+ }
+ bit_reader.skip(1)?; // extensionFlag
+
+ let channel_counts = match channel_configuration {
+ 0 => {
+ debug!("Parsing program_config_element for channel counts");
+
+ bit_reader.skip(4)?; // element_instance_tag
+ bit_reader.skip(2)?; // object_type
+ bit_reader.skip(4)?; // sampling_frequency_index
+ let num_front_channel: u8 = ReadInto::read(bit_reader, 4)?;
+ let num_side_channel: u8 = ReadInto::read(bit_reader, 4)?;
+ let num_back_channel: u8 = ReadInto::read(bit_reader, 4)?;
+ let num_lfe_channel: u8 = ReadInto::read(bit_reader, 2)?;
+ bit_reader.skip(3)?; // num_assoc_data
+ bit_reader.skip(4)?; // num_valid_cc
+
+ let mono_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
+ if mono_mixdown_present {
+ bit_reader.skip(4)?; // mono_mixdown_element_number
+ }
+
+ let stereo_mixdown_present: bool = ReadInto::read(bit_reader, 1)?;
+ if stereo_mixdown_present {
+ bit_reader.skip(4)?; // stereo_mixdown_element_number
+ }
+
+ let matrix_mixdown_idx_present: bool = ReadInto::read(bit_reader, 1)?;
+ if matrix_mixdown_idx_present {
+ bit_reader.skip(2)?; // matrix_mixdown_idx
+ bit_reader.skip(1)?; // pseudo_surround_enable
+ }
+ let mut _channel_counts = 0;
+ _channel_counts += read_surround_channel_count(bit_reader, num_front_channel)?;
+ _channel_counts += read_surround_channel_count(bit_reader, num_side_channel)?;
+ _channel_counts += read_surround_channel_count(bit_reader, num_back_channel)?;
+ _channel_counts += read_surround_channel_count(bit_reader, num_lfe_channel)?;
+ _channel_counts
+ }
+ 1..=7 => channel_configuration,
+ // Amendment 4 of the AAC standard in 2013 below
+ 11 => 7, // 6.1 Amendment 4 of the AAC standard in 2013
+ 12 | 14 => 8, // 7.1 (a/d) of ITU BS.2159
+ _ => {
+ return Err(Error::Unsupported("invalid channel configuration"));
+ }
+ };
+
+ esds.audio_object_type = Some(audio_object_type);
+ esds.extended_audio_object_type = extended_audio_object_type;
+ esds.audio_sample_rate = Some(sample_frequency_value);
+ esds.audio_channel_count = Some(channel_counts);
+ if !esds.decoder_specific_data.is_empty() {
+ return Status::EsdsDecSpecificIntoTagQuantity.into();
+ }
+ esds.decoder_specific_data.extend_from_slice(data)?;
+
+ Ok(())
+ }
+ _ => Err(Error::Unsupported("unknown aac audio object type")),
+ }
+}
+
+fn read_surround_channel_count(bit_reader: &mut BitReader, channels: u8) -> Result<u16> {
+ let mut count = 0;
+ for _ in 0..channels {
+ let is_cpe: bool = ReadInto::read(bit_reader, 1)?;
+ count += if is_cpe { 2 } else { 1 };
+ bit_reader.skip(4)?;
+ }
+ Ok(count)
+}
+
+/// See MPEG-4 Systems (ISO 14496-1:2010) § 7.2.6.6
+fn read_dc_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
+ let des = &mut Cursor::new(data);
+ let object_profile = des.read_u8()?;
+
+ #[cfg(feature = "mp4v")]
+ {
+ esds.video_codec = match object_profile {
+ 0x20..=0x24 => CodecType::MP4V,
+ _ => CodecType::Unknown,
+ };
+ }
+
+ // Skip uninteresting fields.
+ skip(des, 12)?;
+
+ if data.len().to_u64() > des.position() {
+ find_descriptor(&data[des.position().try_into()?..data.len()], esds)?;
+ }
+
+ esds.audio_codec = match object_profile {
+ 0x40 | 0x66 | 0x67 => CodecType::AAC,
+ 0x69 | 0x6B => CodecType::MP3,
+ _ => CodecType::Unknown,
+ };
+
+ debug!(
+ "read_dc_descriptor: esds.audio_codec = {:?}",
+ esds.audio_codec
+ );
+
+ Ok(())
+}
+
+/// See MPEG-4 Systems (ISO 14496-1:2010) § 7.2.6.5
+fn read_es_descriptor(data: &[u8], esds: &mut ES_Descriptor) -> Result<()> {
+ let des = &mut Cursor::new(data);
+
+ skip(des, 2)?;
+
+ let esds_flags = des.read_u8()?;
+
+ // Stream dependency flag, first bit from left most.
+ if esds_flags & 0x80 > 0 {
+ // Skip uninteresting fields.
+ skip(des, 2)?;
+ }
+
+ // Url flag, second bit from left most.
+ if esds_flags & 0x40 > 0 {
+ // Skip uninteresting fields.
+ let skip_es_len = u64::from(des.read_u8()?) + 2;
+ skip(des, skip_es_len)?;
+ }
+
+ if data.len().to_u64() > des.position() {
+ find_descriptor(&data[des.position().try_into()?..data.len()], esds)?;
+ }
+
+ Ok(())
+}
+
+/// See MP4 (ISO 14496-14:2020) § 6.7.2
+fn read_esds<T: Read>(src: &mut BMFFBox<T>) -> Result<ES_Descriptor> {
+ let (_, _) = read_fullbox_extra(src)?;
+
+ let esds_array = read_buf(src, src.bytes_left())?;
+
+ let mut es_data = ES_Descriptor::default();
+ find_descriptor(&esds_array, &mut es_data)?;
+
+ es_data.codec_esds = esds_array;
+
+ Ok(es_data)
+}
+
+/// Parse `FLACSpecificBox`.
+/// See [Encapsulation of FLAC in ISO Base Media File Format](https://github.com/xiph/flac/blob/master/doc/isoflac.txt) § 3.3.2
+fn read_dfla<T: Read>(src: &mut BMFFBox<T>) -> Result<FLACSpecificBox> {
+ let (version, flags) = read_fullbox_extra(src)?;
+ if version != 0 {
+ return Err(Error::Unsupported("unknown dfLa (FLAC) version"));
+ }
+ if flags != 0 {
+ return Status::DflaFlagsNonzero.into();
+ }
+ let mut blocks = TryVec::new();
+ while src.bytes_left() > 0 {
+ let block = read_flac_metadata(src)?;
+ blocks.push(block)?;
+ }
+ // The box must have at least one meta block, and the first block
+ // must be the METADATA_BLOCK_STREAMINFO
+ if blocks.is_empty() {
+ return Status::DflaMissingMetadata.into();
+ } else if blocks[0].block_type != 0 {
+ return Status::DflaStreamInfoNotFirst.into();
+ } else if blocks[0].data.len() != 34 {
+ return Status::DflaStreamInfoBadSize.into();
+ }
+ Ok(FLACSpecificBox { version, blocks })
+}
+
+/// Parse `OpusSpecificBox`.
+fn read_dops<T: Read>(src: &mut BMFFBox<T>) -> Result<OpusSpecificBox> {
+ let version = src.read_u8()?;
+ if version != 0 {
+ return Err(Error::Unsupported("unknown dOps (Opus) version"));
+ }
+
+ let output_channel_count = src.read_u8()?;
+ let pre_skip = be_u16(src)?;
+ let input_sample_rate = be_u32(src)?;
+ let output_gain = be_i16(src)?;
+ let channel_mapping_family = src.read_u8()?;
+
+ let channel_mapping_table = if channel_mapping_family == 0 {
+ None
+ } else {
+ let stream_count = src.read_u8()?;
+ let coupled_count = src.read_u8()?;
+ let channel_mapping = read_buf(src, output_channel_count.into())?;
+
+ Some(ChannelMappingTable {
+ stream_count,
+ coupled_count,
+ channel_mapping,
+ })
+ };
+
+ // TODO(kinetik): validate field value ranges.
+ Ok(OpusSpecificBox {
+ version,
+ output_channel_count,
+ pre_skip,
+ input_sample_rate,
+ output_gain,
+ channel_mapping_family,
+ channel_mapping_table,
+ })
+}
+
+/// Re-serialize the Opus codec-specific config data as an `OpusHead` packet.
+///
+/// Some decoders expect the initialization data in the format used by the
+/// Ogg and WebM encapsulations. To support this we prepend the `OpusHead`
+/// tag and byte-swap the data from big- to little-endian relative to the
+/// dOps box.
+pub fn serialize_opus_header<W: byteorder::WriteBytesExt + std::io::Write>(
+ opus: &OpusSpecificBox,
+ dst: &mut W,
+) -> Result<()> {
+ match dst.write(b"OpusHead") {
+ Err(e) => return Err(Error::from(e)),
+ Ok(bytes) => {
+ if bytes != 8 {
+ return Status::DopsOpusHeadWriteErr.into();
+ }
+ }
+ }
+ // In mp4 encapsulation, the version field is 0, but in ogg
+ // it is 1. While decoders generally accept zero as well, write
+ // out the version of the header we're supporting rather than
+ // whatever we parsed out of mp4.
+ dst.write_u8(1)?;
+ dst.write_u8(opus.output_channel_count)?;
+ dst.write_u16::<byteorder::LittleEndian>(opus.pre_skip)?;
+ dst.write_u32::<byteorder::LittleEndian>(opus.input_sample_rate)?;
+ dst.write_i16::<byteorder::LittleEndian>(opus.output_gain)?;
+ dst.write_u8(opus.channel_mapping_family)?;
+ match opus.channel_mapping_table {
+ None => {}
+ Some(ref table) => {
+ dst.write_u8(table.stream_count)?;
+ dst.write_u8(table.coupled_count)?;
+ match dst.write(&table.channel_mapping) {
+ Err(e) => return Err(Error::from(e)),
+ Ok(bytes) => {
+ if bytes != table.channel_mapping.len() {
+ return Status::DopsChannelMappingWriteErr.into();
+ }
+ }
+ }
+ }
+ };
+ Ok(())
+}
+
+/// Parse `ALACSpecificBox`.
+fn read_alac<T: Read>(src: &mut BMFFBox<T>) -> Result<ALACSpecificBox> {
+ let (version, flags) = read_fullbox_extra(src)?;
+ if version != 0 {
+ return Err(Error::Unsupported("unknown alac (ALAC) version"));
+ }
+ if flags != 0 {
+ return Status::AlacFlagsNonzero.into();
+ }
+
+ let length = match src.bytes_left() {
+ x @ 24 | x @ 48 => x,
+ _ => {
+ return Status::AlacBadMagicCookieSize.into();
+ }
+ };
+ let data = read_buf(src, length)?;
+
+ Ok(ALACSpecificBox { version, data })
+}
+
+/// Parse a Handler Reference Box.<br />
+/// See ISOBMFF (ISO 14496-12:2020) § 8.4.3<br />
+/// See [\[ISOBMFF\]: reserved (field = 0;) handling is ambiguous](https://github.com/MPEGGroup/FileFormat/issues/36)
+fn read_hdlr<T: Read>(src: &mut BMFFBox<T>, strictness: ParseStrictness) -> Result<HandlerBox> {
+ if read_fullbox_version_no_flags(src)? != 0 {
+ return Status::HdlrUnsupportedVersion.into();
+ }
+
+ let pre_defined = be_u32(src)?;
+ if pre_defined != 0 {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::HdlrPredefinedNonzero,
+ )?;
+ }
+
+ let handler_type = FourCC::from(be_u32(src)?);
+
+ for _ in 1..=3 {
+ let reserved = be_u32(src)?;
+ if reserved != 0 {
+ fail_with_status_if(
+ strictness == ParseStrictness::Strict,
+ Status::HdlrReservedNonzero,
+ )?;
+ }
+ }
+
+ match std::str::from_utf8(src.read_into_try_vec()?.as_slice()) {
+ Ok(name) => {
+ match name.bytes().position(|b| b == b'\0') {
+ None => fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::HdlrNameNoNul,
+ )?,
+ // `name` must be nul-terminated and any trailing bytes after the first nul ignored.
+ // See https://github.com/MPEGGroup/FileFormat/issues/35
+ Some(_) => (),
+ }
+ }
+ Err(_) => fail_with_status_if(
+ strictness != ParseStrictness::Permissive,
+ Status::HdlrNameNotUtf8,
+ )?,
+ }
+
+ Ok(HandlerBox { handler_type })
+}
+
+/// Parse an video description inside an stsd box.
+fn read_video_sample_entry<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleEntry> {
+ let name = src.get_header().name;
+ let codec_type = match name {
+ BoxType::AVCSampleEntry | BoxType::AVC3SampleEntry => CodecType::H264,
+ BoxType::MP4VideoSampleEntry => CodecType::MP4V,
+ BoxType::VP8SampleEntry => CodecType::VP8,
+ BoxType::VP9SampleEntry => CodecType::VP9,
+ BoxType::AV1SampleEntry => CodecType::AV1,
+ BoxType::ProtectedVisualSampleEntry => CodecType::EncryptedVideo,
+ BoxType::H263SampleEntry => CodecType::H263,
+ BoxType::HEV1SampleEntry | BoxType::HVC1SampleEntry => CodecType::HEVC,
+ _ => {
+ debug!("Unsupported video codec, box {:?} found", name);
+ CodecType::Unknown
+ }
+ };
+
+ // Skip uninteresting fields.
+ skip(src, 6)?;
+
+ let data_reference_index = be_u16(src)?;
+
+ // Skip uninteresting fields.
+ skip(src, 16)?;
+
+ let width = be_u16(src)?;
+ let height = be_u16(src)?;
+
+ // Skip uninteresting fields.
+ skip(src, 50)?;
+
+ // Skip clap/pasp/etc. for now.
+ let mut codec_specific = None;
+ let mut protection_info = TryVec::new();
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::AVCConfigurationBox => {
+ if (name != BoxType::AVCSampleEntry
+ && name != BoxType::AVC3SampleEntry
+ && name != BoxType::ProtectedVisualSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let avcc_size = b
+ .head
+ .size
+ .checked_sub(b.head.offset)
+ .expect("offset invalid");
+ let avcc = read_buf(&mut b.content, avcc_size)?;
+ debug!("{:?} (avcc)", avcc);
+ // TODO(kinetik): Parse avcC box? For now we just stash the data.
+ codec_specific = Some(VideoCodecSpecific::AVCConfig(avcc));
+ }
+ BoxType::H263SpecificBox => {
+ if (name != BoxType::H263SampleEntry) || codec_specific.is_some() {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let h263_dec_spec_struc_size = b
+ .head
+ .size
+ .checked_sub(b.head.offset)
+ .expect("offset invalid");
+ let h263_dec_spec_struc = read_buf(&mut b.content, h263_dec_spec_struc_size)?;
+ debug!("{:?} (h263DecSpecStruc)", h263_dec_spec_struc);
+
+ codec_specific = Some(VideoCodecSpecific::H263Config(h263_dec_spec_struc));
+ }
+ BoxType::VPCodecConfigurationBox => {
+ // vpcC
+ if (name != BoxType::VP8SampleEntry
+ && name != BoxType::VP9SampleEntry
+ && name != BoxType::ProtectedVisualSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let vpcc = read_vpcc(&mut b)?;
+ codec_specific = Some(VideoCodecSpecific::VPxConfig(vpcc));
+ }
+ BoxType::AV1CodecConfigurationBox => {
+ if name != BoxType::AV1SampleEntry && name != BoxType::ProtectedVisualSampleEntry {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let av1c = read_av1c(&mut b)?;
+ codec_specific = Some(VideoCodecSpecific::AV1Config(av1c));
+ }
+ BoxType::ESDBox => {
+ if name != BoxType::MP4VideoSampleEntry || codec_specific.is_some() {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ #[cfg(not(feature = "mp4v"))]
+ {
+ let (_, _) = read_fullbox_extra(&mut b.content)?;
+ // Subtract 4 extra to offset the members of fullbox not
+ // accounted for in head.offset
+ let esds_size = b
+ .head
+ .size
+ .checked_sub(b.head.offset + 4)
+ .expect("offset invalid");
+ let esds = read_buf(&mut b.content, esds_size)?;
+ codec_specific = Some(VideoCodecSpecific::ESDSConfig(esds));
+ }
+ #[cfg(feature = "mp4v")]
+ {
+ // Read ES_Descriptor inside an esds box.
+ // See ISOBMFF (ISO 14496-1:2010) § 7.2.6.5
+ let esds = read_esds(&mut b)?;
+ codec_specific =
+ Some(VideoCodecSpecific::ESDSConfig(esds.decoder_specific_data));
+ }
+ }
+ BoxType::ProtectionSchemeInfoBox => {
+ if name != BoxType::ProtectedVisualSampleEntry {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let sinf = read_sinf(&mut b)?;
+ debug!("{:?} (sinf)", sinf);
+ protection_info.push(sinf)?;
+ }
+ BoxType::HEVCConfigurationBox => {
+ if (name != BoxType::HEV1SampleEntry
+ && name != BoxType::HVC1SampleEntry
+ && name != BoxType::ProtectedVisualSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadVideoSampleEntry.into();
+ }
+ let hvcc_size = b
+ .head
+ .size
+ .checked_sub(b.head.offset)
+ .expect("offset invalid");
+ let hvcc = read_buf(&mut b.content, hvcc_size)?;
+ debug!("{:?} (hvcc)", hvcc);
+ codec_specific = Some(VideoCodecSpecific::HEVCConfig(hvcc));
+ }
+ _ => {
+ debug!("Unsupported video codec, box {:?} found", b.head.name);
+ skip_box_content(&mut b)?;
+ }
+ }
+ check_parser_state!(b.content);
+ }
+
+ Ok(
+ codec_specific.map_or(SampleEntry::Unknown, |codec_specific| {
+ SampleEntry::Video(VideoSampleEntry {
+ codec_type,
+ data_reference_index,
+ width,
+ height,
+ codec_specific,
+ protection_info,
+ })
+ }),
+ )
+}
+
+fn read_qt_wave_atom<T: Read>(src: &mut BMFFBox<T>) -> Result<ES_Descriptor> {
+ let mut codec_specific = None;
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::ESDBox => {
+ let esds = read_esds(&mut b)?;
+ codec_specific = Some(esds);
+ }
+ _ => skip_box_content(&mut b)?,
+ }
+ }
+
+ codec_specific.ok_or_else(|| Error::from(Status::EsdsBadAudioSampleEntry))
+}
+
+/// Parse an audio description inside an stsd box.
+/// See ISOBMFF (ISO 14496-12:2020) § 12.2.3
+fn read_audio_sample_entry<T: Read>(src: &mut BMFFBox<T>) -> Result<SampleEntry> {
+ let name = src.get_header().name;
+
+ // Skip uninteresting fields.
+ skip(src, 6)?;
+
+ let data_reference_index = be_u16(src)?;
+
+ // XXX(kinetik): This is "reserved" in BMFF, but some old QT MOV variant
+ // uses it, need to work out if we have to support it. Without checking
+ // here and reading extra fields after samplerate (or bailing with an
+ // error), the parser loses sync completely.
+ let version = be_u16(src)?;
+
+ // Skip uninteresting fields.
+ skip(src, 6)?;
+
+ let mut channelcount = u32::from(be_u16(src)?);
+ let samplesize = be_u16(src)?;
+
+ // Skip uninteresting fields.
+ skip(src, 4)?;
+
+ let mut samplerate = f64::from(be_u32(src)? >> 16); // 16.16 fixed point;
+
+ match version {
+ 0 => (),
+ 1 => {
+ // Quicktime sound sample description version 1.
+ // Skip uninteresting fields.
+ skip(src, 16)?;
+ }
+ 2 => {
+ // Quicktime sound sample description version 2.
+ skip(src, 4)?;
+ samplerate = f64::from_bits(be_u64(src)?);
+ channelcount = be_u32(src)?;
+ skip(src, 20)?;
+ }
+ _ => {
+ return Err(Error::Unsupported(
+ "unsupported non-isom audio sample entry",
+ ))
+ }
+ }
+
+ let (mut codec_type, mut codec_specific) = match name {
+ BoxType::MP3AudioSampleEntry => (CodecType::MP3, Some(AudioCodecSpecific::MP3)),
+ BoxType::LPCMAudioSampleEntry => (CodecType::LPCM, Some(AudioCodecSpecific::LPCM)),
+ // Some mp4 file with AMR doesn't have AMRSpecificBox "damr" in followed while loop,
+ // we use empty box by default.
+ #[cfg(feature = "3gpp")]
+ BoxType::AMRNBSampleEntry => (
+ CodecType::AMRNB,
+ Some(AudioCodecSpecific::AMRSpecificBox(Default::default())),
+ ),
+ #[cfg(feature = "3gpp")]
+ BoxType::AMRWBSampleEntry => (
+ CodecType::AMRWB,
+ Some(AudioCodecSpecific::AMRSpecificBox(Default::default())),
+ ),
+ _ => (CodecType::Unknown, None),
+ };
+ let mut protection_info = TryVec::new();
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::ESDBox => {
+ if (name != BoxType::MP4AudioSampleEntry
+ && name != BoxType::ProtectedAudioSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let esds = read_esds(&mut b)?;
+ codec_type = esds.audio_codec;
+ codec_specific = Some(AudioCodecSpecific::ES_Descriptor(esds));
+ }
+ BoxType::FLACSpecificBox => {
+ if (name != BoxType::FLACSampleEntry && name != BoxType::ProtectedAudioSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let dfla = read_dfla(&mut b)?;
+ codec_type = CodecType::FLAC;
+ codec_specific = Some(AudioCodecSpecific::FLACSpecificBox(dfla));
+ }
+ BoxType::OpusSpecificBox => {
+ if (name != BoxType::OpusSampleEntry && name != BoxType::ProtectedAudioSampleEntry)
+ || codec_specific.is_some()
+ {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let dops = read_dops(&mut b)?;
+ codec_type = CodecType::Opus;
+ codec_specific = Some(AudioCodecSpecific::OpusSpecificBox(dops));
+ }
+ BoxType::ALACSpecificBox => {
+ if name != BoxType::ALACSpecificBox || codec_specific.is_some() {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let alac = read_alac(&mut b)?;
+ codec_type = CodecType::ALAC;
+ codec_specific = Some(AudioCodecSpecific::ALACSpecificBox(alac));
+ }
+ BoxType::QTWaveAtom => {
+ let qt_esds = read_qt_wave_atom(&mut b)?;
+ codec_type = qt_esds.audio_codec;
+ codec_specific = Some(AudioCodecSpecific::ES_Descriptor(qt_esds));
+ }
+ BoxType::ProtectionSchemeInfoBox => {
+ if name != BoxType::ProtectedAudioSampleEntry {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let sinf = read_sinf(&mut b)?;
+ debug!("{:?} (sinf)", sinf);
+ codec_type = CodecType::EncryptedAudio;
+ protection_info.push(sinf)?;
+ }
+ #[cfg(feature = "3gpp")]
+ BoxType::AMRSpecificBox => {
+ if codec_type != CodecType::AMRNB && codec_type != CodecType::AMRWB {
+ return Status::StsdBadAudioSampleEntry.into();
+ }
+ let amr_dec_spec_struc_size = b
+ .head
+ .size
+ .checked_sub(b.head.offset)
+ .expect("offset invalid");
+ let amr_dec_spec_struc = read_buf(&mut b.content, amr_dec_spec_struc_size)?;
+ debug!("{:?} (AMRDecSpecStruc)", amr_dec_spec_struc);
+ codec_specific = Some(AudioCodecSpecific::AMRSpecificBox(amr_dec_spec_struc));
+ }
+ _ => {
+ debug!("Unsupported audio codec, box {:?} found", b.head.name);
+ skip_box_content(&mut b)?;
+ }
+ }
+ check_parser_state!(b.content);
+ }
+
+ Ok(
+ codec_specific.map_or(SampleEntry::Unknown, |codec_specific| {
+ SampleEntry::Audio(AudioSampleEntry {
+ codec_type,
+ data_reference_index,
+ channelcount,
+ samplesize,
+ samplerate,
+ codec_specific,
+ protection_info,
+ })
+ }),
+ )
+}
+
+/// Parse a stsd box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.5.2
+/// See MP4 (ISO 14496-14:2020) § 6.7.2
+fn read_stsd<T: Read>(src: &mut BMFFBox<T>, track: &Track) -> Result<SampleDescriptionBox> {
+ let (_, flags) = read_fullbox_extra(src)?;
+
+ if flags != 0 {
+ warn!(
+ "Unexpected `flags` value for SampleDescriptionBox (stsd): {}",
+ flags
+ );
+ }
+
+ let description_count = be_u32(src)?.to_usize();
+ let mut descriptions = TryVec::with_capacity(description_count)?;
+
+ let mut iter = src.box_iter();
+ while descriptions.len() < description_count {
+ if let Some(mut b) = iter.next_box()? {
+ let description = match track.track_type {
+ TrackType::Video => read_video_sample_entry(&mut b),
+ TrackType::Picture => read_video_sample_entry(&mut b),
+ TrackType::AuxiliaryVideo => read_video_sample_entry(&mut b),
+ TrackType::Audio => read_audio_sample_entry(&mut b),
+ TrackType::Metadata => Err(Error::Unsupported("metadata track")),
+ TrackType::Unknown => Err(Error::Unsupported("unknown track type")),
+ };
+ let description = match description {
+ Ok(desc) => desc,
+ Err(Error::Unsupported(_)) => {
+ // read_{audio,video}_desc may have returned Unsupported
+ // after partially reading the box content, so we can't
+ // simply use skip_box_content here.
+ let to_skip = b.bytes_left();
+ skip(&mut b, to_skip)?;
+ SampleEntry::Unknown
+ }
+ Err(e) => return Err(e),
+ };
+ descriptions.push(description)?;
+ check_parser_state!(b.content);
+ } else {
+ break;
+ }
+ }
+
+ // Padding could be added in some contents.
+ skip_box_remain(src)?;
+
+ Ok(SampleDescriptionBox { descriptions })
+}
+
+fn read_sinf<T: Read>(src: &mut BMFFBox<T>) -> Result<ProtectionSchemeInfoBox> {
+ let mut sinf = ProtectionSchemeInfoBox::default();
+
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::OriginalFormatBox => {
+ sinf.original_format = FourCC::from(be_u32(&mut b)?);
+ }
+ BoxType::SchemeTypeBox => {
+ sinf.scheme_type = Some(read_schm(&mut b)?);
+ }
+ BoxType::SchemeInformationBox => {
+ // We only need tenc box in schi box so far.
+ sinf.tenc = read_schi(&mut b)?;
+ }
+ _ => skip_box_content(&mut b)?,
+ }
+ check_parser_state!(b.content);
+ }
+
+ Ok(sinf)
+}
+
+fn read_schi<T: Read>(src: &mut BMFFBox<T>) -> Result<Option<TrackEncryptionBox>> {
+ let mut tenc = None;
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::TrackEncryptionBox => {
+ if tenc.is_some() {
+ return Status::SchiQuantity.into();
+ }
+ tenc = Some(read_tenc(&mut b)?);
+ }
+ _ => skip_box_content(&mut b)?,
+ }
+ }
+
+ Ok(tenc)
+}
+
+fn read_tenc<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackEncryptionBox> {
+ let (version, _) = read_fullbox_extra(src)?;
+
+ // reserved byte
+ skip(src, 1)?;
+ // the next byte is used to signal the default pattern in version >= 1
+ let (default_crypt_byte_block, default_skip_byte_block) = match version {
+ 0 => {
+ skip(src, 1)?;
+ (None, None)
+ }
+ _ => {
+ let pattern_byte = src.read_u8()?;
+ let crypt_bytes = pattern_byte >> 4;
+ let skip_bytes = pattern_byte & 0x0f;
+ (Some(crypt_bytes), Some(skip_bytes))
+ }
+ };
+ let default_is_encrypted = src.read_u8()?;
+ let default_iv_size = src.read_u8()?;
+ let default_kid = read_buf(src, 16)?;
+ // If default_is_encrypted == 1 && default_iv_size == 0 we expect a default_constant_iv
+ let default_constant_iv = match (default_is_encrypted, default_iv_size) {
+ (1, 0) => {
+ let default_constant_iv_size = src.read_u8()?;
+ Some(read_buf(src, default_constant_iv_size.into())?)
+ }
+ _ => None,
+ };
+
+ Ok(TrackEncryptionBox {
+ is_encrypted: default_is_encrypted,
+ iv_size: default_iv_size,
+ kid: default_kid,
+ crypt_byte_block_count: default_crypt_byte_block,
+ skip_byte_block_count: default_skip_byte_block,
+ constant_iv: default_constant_iv,
+ })
+}
+
+fn read_schm<T: Read>(src: &mut BMFFBox<T>) -> Result<SchemeTypeBox> {
+ // Flags can be used to signal presence of URI in the box, but we don't
+ // use the URI so don't bother storing the flags.
+ let (_, _) = read_fullbox_extra(src)?;
+ let scheme_type = FourCC::from(be_u32(src)?);
+ let scheme_version = be_u32(src)?;
+ // Null terminated scheme URI may follow, but we don't use it right now.
+ skip_box_remain(src)?;
+ Ok(SchemeTypeBox {
+ scheme_type,
+ scheme_version,
+ })
+}
+
+/// Parse a metadata box inside a moov, trak, or mdia box.
+/// See ISOBMFF (ISO 14496-12:2020) § 8.10.1.
+fn read_udta<T: Read>(src: &mut BMFFBox<T>) -> Result<UserdataBox> {
+ let mut iter = src.box_iter();
+ let mut udta = UserdataBox { meta: None };
+
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MetadataBox => {
+ let meta = read_meta(&mut b)?;
+ udta.meta = Some(meta);
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(udta)
+}
+
+/// Parse the meta box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.1
+fn read_meta<T: Read>(src: &mut BMFFBox<T>) -> Result<MetadataBox> {
+ let (_, _) = read_fullbox_extra(src)?;
+ let mut iter = src.box_iter();
+ let mut meta = MetadataBox::default();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MetadataItemListEntry => read_ilst(&mut b, &mut meta)?,
+ #[cfg(feature = "meta-xml")]
+ BoxType::MetadataXMLBox => read_xml_(&mut b, &mut meta)?,
+ #[cfg(feature = "meta-xml")]
+ BoxType::MetadataBXMLBox => read_bxml(&mut b, &mut meta)?,
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(meta)
+}
+
+/// Parse a XML box inside a meta box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.2
+#[cfg(feature = "meta-xml")]
+fn read_xml_<T: Read>(src: &mut BMFFBox<T>, meta: &mut MetadataBox) -> Result<()> {
+ if read_fullbox_version_no_flags(src)? != 0 {
+ return Err(Error::Unsupported("unsupported XmlBox version"));
+ }
+ meta.xml = Some(XmlBox::StringXmlBox(src.read_into_try_vec()?));
+ Ok(())
+}
+
+/// Parse a Binary XML box inside a meta box
+/// See ISOBMFF (ISO 14496-12:2020) § 8.11.2
+#[cfg(feature = "meta-xml")]
+fn read_bxml<T: Read>(src: &mut BMFFBox<T>, meta: &mut MetadataBox) -> Result<()> {
+ if read_fullbox_version_no_flags(src)? != 0 {
+ return Err(Error::Unsupported("unsupported XmlBox version"));
+ }
+ meta.xml = Some(XmlBox::BinaryXmlBox(src.read_into_try_vec()?));
+ Ok(())
+}
+
+/// Parse a metadata box inside a udta box
+fn read_ilst<T: Read>(src: &mut BMFFBox<T>, meta: &mut MetadataBox) -> Result<()> {
+ let mut iter = src.box_iter();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::AlbumEntry => meta.album = read_ilst_string_data(&mut b)?,
+ BoxType::ArtistEntry | BoxType::ArtistLowercaseEntry => {
+ meta.artist = read_ilst_string_data(&mut b)?
+ }
+ BoxType::AlbumArtistEntry => meta.album_artist = read_ilst_string_data(&mut b)?,
+ BoxType::CommentEntry => meta.comment = read_ilst_string_data(&mut b)?,
+ BoxType::DateEntry => meta.year = read_ilst_string_data(&mut b)?,
+ BoxType::TitleEntry => meta.title = read_ilst_string_data(&mut b)?,
+ BoxType::CustomGenreEntry => {
+ meta.genre = read_ilst_string_data(&mut b)?.map(Genre::CustomGenre)
+ }
+ BoxType::StandardGenreEntry => {
+ meta.genre = read_ilst_u8_data(&mut b)?
+ .and_then(|gnre| Some(Genre::StandardGenre(gnre.get(1).copied()?)))
+ }
+ BoxType::ComposerEntry => meta.composer = read_ilst_string_data(&mut b)?,
+ BoxType::EncoderEntry => meta.encoder = read_ilst_string_data(&mut b)?,
+ BoxType::EncodedByEntry => meta.encoded_by = read_ilst_string_data(&mut b)?,
+ BoxType::CopyrightEntry => meta.copyright = read_ilst_string_data(&mut b)?,
+ BoxType::GroupingEntry => meta.grouping = read_ilst_string_data(&mut b)?,
+ BoxType::CategoryEntry => meta.category = read_ilst_string_data(&mut b)?,
+ BoxType::KeywordEntry => meta.keyword = read_ilst_string_data(&mut b)?,
+ BoxType::PodcastUrlEntry => meta.podcast_url = read_ilst_string_data(&mut b)?,
+ BoxType::PodcastGuidEntry => meta.podcast_guid = read_ilst_string_data(&mut b)?,
+ BoxType::DescriptionEntry => meta.description = read_ilst_string_data(&mut b)?,
+ BoxType::LongDescriptionEntry => meta.long_description = read_ilst_string_data(&mut b)?,
+ BoxType::LyricsEntry => meta.lyrics = read_ilst_string_data(&mut b)?,
+ BoxType::TVNetworkNameEntry => meta.tv_network_name = read_ilst_string_data(&mut b)?,
+ BoxType::TVEpisodeNameEntry => meta.tv_episode_name = read_ilst_string_data(&mut b)?,
+ BoxType::TVShowNameEntry => meta.tv_show_name = read_ilst_string_data(&mut b)?,
+ BoxType::PurchaseDateEntry => meta.purchase_date = read_ilst_string_data(&mut b)?,
+ BoxType::RatingEntry => meta.rating = read_ilst_string_data(&mut b)?,
+ BoxType::OwnerEntry => meta.owner = read_ilst_string_data(&mut b)?,
+ BoxType::HDVideoEntry => meta.hd_video = read_ilst_bool_data(&mut b)?,
+ BoxType::SortNameEntry => meta.sort_name = read_ilst_string_data(&mut b)?,
+ BoxType::SortArtistEntry => meta.sort_artist = read_ilst_string_data(&mut b)?,
+ BoxType::SortAlbumEntry => meta.sort_album = read_ilst_string_data(&mut b)?,
+ BoxType::SortAlbumArtistEntry => {
+ meta.sort_album_artist = read_ilst_string_data(&mut b)?
+ }
+ BoxType::SortComposerEntry => meta.sort_composer = read_ilst_string_data(&mut b)?,
+ BoxType::TrackNumberEntry => {
+ if let Some(trkn) = read_ilst_u8_data(&mut b)? {
+ meta.track_number = trkn.get(3).copied();
+ meta.total_tracks = trkn.get(5).copied();
+ };
+ }
+ BoxType::DiskNumberEntry => {
+ if let Some(disk) = read_ilst_u8_data(&mut b)? {
+ meta.disc_number = disk.get(3).copied();
+ meta.total_discs = disk.get(5).copied();
+ };
+ }
+ BoxType::TempoEntry => {
+ meta.beats_per_minute =
+ read_ilst_u8_data(&mut b)?.and_then(|tmpo| tmpo.get(1).copied())
+ }
+ BoxType::CompilationEntry => meta.compilation = read_ilst_bool_data(&mut b)?,
+ BoxType::AdvisoryEntry => {
+ meta.advisory = read_ilst_u8_data(&mut b)?.and_then(|rtng| {
+ Some(match rtng.first()? {
+ 2 => AdvisoryRating::Clean,
+ 0 => AdvisoryRating::Inoffensive,
+ r => AdvisoryRating::Explicit(*r),
+ })
+ })
+ }
+ BoxType::MediaTypeEntry => {
+ meta.media_type = read_ilst_u8_data(&mut b)?.and_then(|stik| {
+ Some(match stik.first()? {
+ 0 => MediaType::Movie,
+ 1 => MediaType::Normal,
+ 2 => MediaType::AudioBook,
+ 5 => MediaType::WhackedBookmark,
+ 6 => MediaType::MusicVideo,
+ 9 => MediaType::ShortFilm,
+ 10 => MediaType::TVShow,
+ 11 => MediaType::Booklet,
+ s => MediaType::Unknown(*s),
+ })
+ })
+ }
+ BoxType::PodcastEntry => meta.podcast = read_ilst_bool_data(&mut b)?,
+ BoxType::TVSeasonNumberEntry => {
+ meta.tv_season = read_ilst_u8_data(&mut b)?.and_then(|tvsn| tvsn.get(3).copied())
+ }
+ BoxType::TVEpisodeNumberEntry => {
+ meta.tv_episode_number =
+ read_ilst_u8_data(&mut b)?.and_then(|tves| tves.get(3).copied())
+ }
+ BoxType::GaplessPlaybackEntry => meta.gapless_playback = read_ilst_bool_data(&mut b)?,
+ BoxType::CoverArtEntry => meta.cover_art = read_ilst_multiple_u8_data(&mut b).ok(),
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(())
+}
+
+fn read_ilst_bool_data<T: Read>(src: &mut BMFFBox<T>) -> Result<Option<bool>> {
+ Ok(read_ilst_u8_data(src)?.and_then(|d| Some(d.first()? == &1)))
+}
+
+fn read_ilst_string_data<T: Read>(src: &mut BMFFBox<T>) -> Result<Option<TryString>> {
+ read_ilst_u8_data(src)
+}
+
+fn read_ilst_u8_data<T: Read>(src: &mut BMFFBox<T>) -> Result<Option<TryVec<u8>>> {
+ // For all non-covr atoms, there must only be one data atom.
+ Ok(read_ilst_multiple_u8_data(src)?.pop())
+}
+
+fn read_ilst_multiple_u8_data<T: Read>(src: &mut BMFFBox<T>) -> Result<TryVec<TryVec<u8>>> {
+ let mut iter = src.box_iter();
+ let mut data = TryVec::new();
+ while let Some(mut b) = iter.next_box()? {
+ match b.head.name {
+ BoxType::MetadataItemDataEntry => {
+ data.push(read_ilst_data(&mut b)?)?;
+ }
+ _ => skip_box_content(&mut b)?,
+ };
+ check_parser_state!(b.content);
+ }
+ Ok(data)
+}
+
+fn read_ilst_data<T: Read>(src: &mut BMFFBox<T>) -> Result<TryVec<u8>> {
+ // Skip past the padding bytes
+ skip(&mut src.content, src.head.offset)?;
+ let size = src.content.limit();
+ read_buf(&mut src.content, size)
+}
+
+/// Skip a number of bytes that we don't care to parse.
+fn skip<T: Read>(src: &mut T, bytes: u64) -> Result<()> {
+ std::io::copy(&mut src.take(bytes), &mut std::io::sink())?;
+ Ok(())
+}
+
+/// Read size bytes into a Vector or return error.
+fn read_buf<T: Read>(src: &mut T, size: u64) -> Result<TryVec<u8>> {
+ let buf = src.take(size).read_into_try_vec()?;
+ if buf.len().to_u64() != size {
+ return Status::ReadBufErr.into();
+ }
+
+ Ok(buf)
+}
+
+fn be_i16<T: ReadBytesExt>(src: &mut T) -> Result<i16> {
+ src.read_i16::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_i32<T: ReadBytesExt>(src: &mut T) -> Result<i32> {
+ src.read_i32::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_i64<T: ReadBytesExt>(src: &mut T) -> Result<i64> {
+ src.read_i64::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_u16<T: ReadBytesExt>(src: &mut T) -> Result<u16> {
+ src.read_u16::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_u24<T: ReadBytesExt>(src: &mut T) -> Result<u32> {
+ src.read_u24::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_u32<T: ReadBytesExt>(src: &mut T) -> Result<u32> {
+ src.read_u32::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn be_u64<T: ReadBytesExt>(src: &mut T) -> Result<u64> {
+ src.read_u64::<byteorder::BigEndian>().map_err(From::from)
+}
+
+fn write_be_u32<T: WriteBytesExt>(des: &mut T, num: u32) -> Result<()> {
+ des.write_u32::<byteorder::BigEndian>(num)
+ .map_err(From::from)
+}
+
+#[cfg(test)]
+mod media_data_box_tests {
+ use super::*;
+
+ impl DataBox {
+ fn at_offset(file_offset: u64, data: std::vec::Vec<u8>) -> Self {
+ DataBox {
+ metadata: DataBoxMetadata::Mdat { file_offset },
+ data: data.into(),
+ }
+ }
+ }
+
+ #[test]
+ fn extent_with_length_before_mdat_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength { offset: 0, len: 2 };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_to_end_before_mdat_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::ToEnd { offset: 0 };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_with_length_crossing_front_mdat_boundary_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength { offset: 99, len: 3 };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_with_length_which_is_subset_of_mdat() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength {
+ offset: 101,
+ len: 2,
+ };
+
+ assert_eq!(mdat.get(&extent), Some(&[1, 1][..]));
+ }
+
+ #[test]
+ fn extent_to_end_which_is_subset_of_mdat() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::ToEnd { offset: 101 };
+
+ assert_eq!(mdat.get(&extent), Some(&[1, 1, 1, 1][..]));
+ }
+
+ #[test]
+ fn extent_with_length_which_is_all_of_mdat() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength {
+ offset: 100,
+ len: 5,
+ };
+
+ assert_eq!(mdat.get(&extent), Some(mdat.data.as_slice()));
+ }
+
+ #[test]
+ fn extent_to_end_which_is_all_of_mdat() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::ToEnd { offset: 100 };
+
+ assert_eq!(mdat.get(&extent), Some(mdat.data.as_slice()));
+ }
+
+ #[test]
+ fn extent_with_length_crossing_back_mdat_boundary_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength {
+ offset: 103,
+ len: 3,
+ };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_with_length_after_mdat_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::WithLength {
+ offset: 200,
+ len: 2,
+ };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_to_end_after_mdat_returns_none() {
+ let mdat = DataBox::at_offset(100, vec![1; 5]);
+ let extent = Extent::ToEnd { offset: 200 };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ #[test]
+ fn extent_with_length_which_overflows_usize() {
+ let mdat = DataBox::at_offset(std::u64::MAX - 1, vec![1; 5]);
+ let extent = Extent::WithLength {
+ offset: std::u64::MAX,
+ len: std::usize::MAX,
+ };
+
+ assert!(mdat.get(&extent).is_none());
+ }
+
+ // The end of the range would overflow `usize` if it were calculated, but
+ // because the range end is unbounded, we don't calculate it.
+ #[test]
+ fn extent_to_end_which_overflows_usize() {
+ let mdat = DataBox::at_offset(std::u64::MAX - 1, vec![1; 5]);
+ let extent = Extent::ToEnd {
+ offset: std::u64::MAX,
+ };
+
+ assert_eq!(mdat.get(&extent), Some(&[1, 1, 1, 1][..]));
+ }
+}
diff --git a/third_party/rust/mp4parse/src/macros.rs b/third_party/rust/mp4parse/src/macros.rs
new file mode 100644
index 0000000000..15244a316f
--- /dev/null
+++ b/third_party/rust/mp4parse/src/macros.rs
@@ -0,0 +1,12 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+macro_rules! check_parser_state {
+ ( $src:expr ) => {
+ if $src.limit() > 0 {
+ debug!("bad parser state: {} content bytes left", $src.limit());
+ return Status::CheckParserStateErr.into();
+ }
+ };
+}
diff --git a/third_party/rust/mp4parse/src/tests.rs b/third_party/rust/mp4parse/src/tests.rs
new file mode 100644
index 0000000000..3eb95f0e37
--- /dev/null
+++ b/third_party/rust/mp4parse/src/tests.rs
@@ -0,0 +1,1366 @@
+//! Module for parsing ISO Base Media Format aka video/mp4 streams.
+//! Internal unit tests.
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use super::read_mp4;
+use super::ParseStrictness;
+use super::{Error, Status};
+use fallible_collections::TryRead as _;
+
+use std::convert::TryInto as _;
+use std::io::Cursor;
+use std::io::Read as _;
+use test_assembler::*;
+
+use crate::boxes::BoxType;
+
+enum BoxSize {
+ Short(u32),
+ Long(u64),
+ UncheckedShort(u32),
+ UncheckedLong(u64),
+ Auto,
+}
+
+#[allow(clippy::trivially_copy_pass_by_ref)] // TODO: Consider reworking to a copy
+fn make_box<F>(size: BoxSize, name: &[u8; 4], func: F) -> Cursor<Vec<u8>>
+where
+ F: Fn(Section) -> Section,
+{
+ let mut section = Section::new();
+ let box_size = Label::new();
+ section = match size {
+ BoxSize::Short(size) | BoxSize::UncheckedShort(size) => section.B32(size),
+ BoxSize::Long(_) | BoxSize::UncheckedLong(_) => section.B32(1),
+ BoxSize::Auto => section.B32(&box_size),
+ };
+ section = section.append_bytes(name);
+ section = match size {
+ // The spec allows the 32-bit size to be 0 to indicate unknown
+ // length streams. It's not clear if this is valid when using a
+ // 64-bit size, so prohibit it for now.
+ BoxSize::Long(size) => {
+ assert!(size > 0);
+ section.B64(size)
+ }
+ BoxSize::UncheckedLong(size) => section.B64(size),
+ _ => section,
+ };
+ section = func(section);
+ match size {
+ BoxSize::Short(size) => {
+ if size > 0 {
+ assert_eq!(u64::from(size), section.size())
+ }
+ }
+ BoxSize::Long(size) => assert_eq!(size, section.size()),
+ BoxSize::Auto => {
+ assert!(
+ section.size() <= u64::from(u32::max_value()),
+ "Tried to use a long box with BoxSize::Auto"
+ );
+ box_size.set_const(section.size());
+ }
+ // Skip checking BoxSize::Unchecked* cases.
+ _ => (),
+ }
+ Cursor::new(section.get_contents().unwrap())
+}
+
+fn make_uuid_box<F>(size: BoxSize, uuid: &[u8; 16], func: F) -> Cursor<Vec<u8>>
+where
+ F: Fn(Section) -> Section,
+{
+ make_box(size, b"uuid", |mut s| {
+ for b in uuid {
+ s = s.B8(*b);
+ }
+ func(s)
+ })
+}
+
+#[allow(clippy::trivially_copy_pass_by_ref)] // TODO: Consider reworking to a copy
+fn make_fullbox<F>(size: BoxSize, name: &[u8; 4], version: u8, func: F) -> Cursor<Vec<u8>>
+where
+ F: Fn(Section) -> Section,
+{
+ make_box(size, name, |s| func(s.B8(version).B8(0).B8(0).B8(0)))
+}
+
+#[test]
+fn read_box_header_short() {
+ let mut stream = make_box(BoxSize::Short(8), b"test", |s| s);
+ let header = super::read_box_header(&mut stream).unwrap();
+ assert_eq!(header.name, BoxType::UnknownBox(0x7465_7374)); // "test"
+ assert_eq!(header.size, 8);
+ assert!(header.uuid.is_none());
+}
+
+#[test]
+fn read_box_header_long() {
+ let mut stream = make_box(BoxSize::Long(16), b"test", |s| s);
+ let header = super::read_box_header(&mut stream).unwrap();
+ assert_eq!(header.name, BoxType::UnknownBox(0x7465_7374)); // "test"
+ assert_eq!(header.size, 16);
+ assert!(header.uuid.is_none());
+}
+
+#[test]
+fn read_box_header_short_unknown_size() {
+ let mut stream = make_box(BoxSize::Short(0), b"test", |s| s);
+ match super::read_box_header(&mut stream) {
+ Err(Error::Unsupported(s)) => assert_eq!(s, "unknown sized box"),
+ _ => panic!("unexpected result reading box with unknown size"),
+ };
+}
+
+#[test]
+fn read_box_header_short_invalid_size() {
+ let mut stream = make_box(BoxSize::UncheckedShort(2), b"test", |s| s);
+ match super::read_box_header(&mut stream) {
+ Err(Error::InvalidData(s)) => assert_eq!(s, Status::BoxBadSize),
+ _ => panic!("unexpected result reading box with invalid size"),
+ };
+}
+
+#[test]
+fn read_box_header_long_invalid_size() {
+ let mut stream = make_box(BoxSize::UncheckedLong(2), b"test", |s| s);
+ match super::read_box_header(&mut stream) {
+ Err(Error::InvalidData(s)) => assert_eq!(s, Status::BoxBadWideSize),
+ _ => panic!("unexpected result reading box with invalid size"),
+ };
+}
+
+#[test]
+fn read_box_header_uuid() {
+ const HEADER_UUID: [u8; 16] = [
+ 0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a,
+ 0x48,
+ ];
+
+ let mut stream = make_uuid_box(BoxSize::Short(24), &HEADER_UUID, |s| s);
+ let mut iter = super::BoxIter::new(&mut stream);
+ let stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::UuidBox);
+ assert_eq!(stream.head.size, 24);
+ assert!(stream.head.uuid.is_some());
+ assert_eq!(stream.head.uuid.unwrap(), HEADER_UUID);
+}
+
+#[test]
+fn read_box_header_truncated_uuid() {
+ const HEADER_UUID: [u8; 16] = [
+ 0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a,
+ 0x48,
+ ];
+
+ let mut stream = make_uuid_box(BoxSize::UncheckedShort(23), &HEADER_UUID, |s| s);
+ let mut iter = super::BoxIter::new(&mut stream);
+ let stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::UuidBox);
+ assert_eq!(stream.head.size, 23);
+ assert!(stream.head.uuid.is_none());
+}
+
+#[test]
+fn read_box_header_uuid_past_eof() {
+ const HEADER_UUID: [u8; 20] = [
+ 0x00, 0x00, 0x00, 0x18, // size = 24
+ 0x75, 0x75, 0x69, 0x64, // type = uuid
+ 0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0, 0x81, 0x11, 0xf4, 0xce,
+ ];
+
+ let mut cursor = Cursor::new(HEADER_UUID);
+ let mut iter = super::BoxIter::new(&mut cursor);
+ match iter.next_box() {
+ Ok(None) => (),
+ Ok(_) => panic!("unexpected box read"),
+ _ => panic!("unexpected error"),
+ };
+}
+
+#[test]
+fn read_ftyp() {
+ let mut stream = make_box(BoxSize::Short(24), b"ftyp", |s| {
+ s.append_bytes(b"mp42")
+ .B32(0) // minor version
+ .append_bytes(b"isom")
+ .append_bytes(b"mp42")
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::FileTypeBox);
+ assert_eq!(stream.head.size, 24);
+ let parsed = super::read_ftyp(&mut stream).unwrap();
+ assert_eq!(parsed.major_brand, b"mp42"); // mp42
+ assert_eq!(parsed.minor_version, 0);
+ assert_eq!(parsed.compatible_brands.len(), 2);
+ assert_eq!(parsed.compatible_brands[0], b"isom"); // isom
+ assert_eq!(parsed.compatible_brands[1], b"mp42"); // mp42
+}
+
+#[test]
+fn read_truncated_ftyp() {
+ // We declare a 24 byte box, but only write 20 bytes.
+ let mut stream = make_box(BoxSize::UncheckedShort(24), b"ftyp", |s| {
+ s.append_bytes(b"mp42")
+ .B32(0) // minor version
+ .append_bytes(b"isom")
+ });
+ match read_mp4(&mut stream) {
+ Err(Error::UnexpectedEOF) => (),
+ Ok(_) => panic!("expected an error result"),
+ _ => panic!("expected a different error result"),
+ }
+}
+
+#[test]
+fn read_ftyp_case() {
+ // Brands in BMFF are represented as a u32, so it would seem clear that
+ // 0x6d703432 ("mp42") is not equal to 0x4d503432 ("MP42"), but some
+ // demuxers treat these as case-insensitive strings, e.g. street.mp4's
+ // major brand is "MP42". I haven't seen case-insensitive
+ // compatible_brands (which we also test here), but it doesn't seem
+ // unlikely given the major_brand behaviour.
+ let mut stream = make_box(BoxSize::Auto, b"ftyp", |s| {
+ s.append_bytes(b"MP42")
+ .B32(0) // minor version
+ .append_bytes(b"ISOM")
+ .append_bytes(b"MP42")
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::FileTypeBox);
+ assert_eq!(stream.head.size, 24);
+ let parsed = super::read_ftyp(&mut stream).unwrap();
+ assert_eq!(parsed.major_brand, b"MP42");
+ assert_eq!(parsed.minor_version, 0);
+ assert_eq!(parsed.compatible_brands.len(), 2);
+ assert_eq!(parsed.compatible_brands[0], b"ISOM"); // ISOM
+ assert_eq!(parsed.compatible_brands[1], b"MP42"); // MP42
+}
+
+#[test]
+fn read_elst_v0() {
+ let mut stream = make_fullbox(BoxSize::Short(28), b"elst", 0, |s| {
+ s.B32(1) // list count
+ // first entry
+ .B32(1234) // duration
+ .B32(5678) // time
+ .B16(12) // rate integer
+ .B16(34) // rate fraction
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::EditListBox);
+ assert_eq!(stream.head.size, 28);
+ let parsed = super::read_elst(&mut stream).unwrap();
+ assert_eq!(parsed.edits.len(), 1);
+ assert_eq!(parsed.edits[0].segment_duration, 1234);
+ assert_eq!(parsed.edits[0].media_time, 5678);
+ assert_eq!(parsed.edits[0].media_rate_integer, 12);
+ assert_eq!(parsed.edits[0].media_rate_fraction, 34);
+}
+
+#[test]
+fn read_elst_v1() {
+ let mut stream = make_fullbox(BoxSize::Short(56), b"elst", 1, |s| {
+ s.B32(2) // list count
+ // first entry
+ .B64(1234) // duration
+ .B64(5678) // time
+ .B16(12) // rate integer
+ .B16(34) // rate fraction
+ // second entry
+ .B64(1234) // duration
+ .B64(5678) // time
+ .B16(12) // rate integer
+ .B16(34) // rate fraction
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::EditListBox);
+ assert_eq!(stream.head.size, 56);
+ let parsed = super::read_elst(&mut stream).unwrap();
+ assert_eq!(parsed.edits.len(), 2);
+ assert_eq!(parsed.edits[1].segment_duration, 1234);
+ assert_eq!(parsed.edits[1].media_time, 5678);
+ assert_eq!(parsed.edits[1].media_rate_integer, 12);
+ assert_eq!(parsed.edits[1].media_rate_fraction, 34);
+}
+
+#[test]
+fn read_mdhd_v0() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"mdhd", 0, |s| {
+ s.B32(0)
+ .B32(0)
+ .B32(1234) // timescale
+ .B32(5678) // duration
+ .B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MediaHeaderBox);
+ assert_eq!(stream.head.size, 32);
+ let parsed = super::read_mdhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, 5678);
+}
+
+#[test]
+fn read_mdhd_v1() {
+ let mut stream = make_fullbox(BoxSize::Short(44), b"mdhd", 1, |s| {
+ s.B64(0)
+ .B64(0)
+ .B32(1234) // timescale
+ .B64(5678) // duration
+ .B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MediaHeaderBox);
+ assert_eq!(stream.head.size, 44);
+ let parsed = super::read_mdhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, 5678);
+}
+
+#[test]
+fn read_mdhd_unknown_duration() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"mdhd", 0, |s| {
+ s.B32(0)
+ .B32(0)
+ .B32(1234) // timescale
+ .B32(::std::u32::MAX) // duration
+ .B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MediaHeaderBox);
+ assert_eq!(stream.head.size, 32);
+ let parsed = super::read_mdhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, ::std::u64::MAX);
+}
+
+#[test]
+fn read_mdhd_invalid_timescale() {
+ let mut stream = make_fullbox(BoxSize::Short(44), b"mdhd", 1, |s| {
+ s.B64(0)
+ .B64(0)
+ .B32(0) // timescale
+ .B64(5678) // duration
+ .B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MediaHeaderBox);
+ assert_eq!(stream.head.size, 44);
+ let r = super::parse_mdhd(&mut stream, &super::Track::new(0));
+ assert!(r.is_err());
+}
+
+#[test]
+fn read_mvhd_v0() {
+ let mut stream = make_fullbox(BoxSize::Short(108), b"mvhd", 0, |s| {
+ s.B32(0).B32(0).B32(1234).B32(5678).append_repeated(0, 80)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MovieHeaderBox);
+ assert_eq!(stream.head.size, 108);
+ let parsed = super::read_mvhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, 5678);
+}
+
+#[test]
+fn read_mvhd_v1() {
+ let mut stream = make_fullbox(BoxSize::Short(120), b"mvhd", 1, |s| {
+ s.B64(0).B64(0).B32(1234).B64(5678).append_repeated(0, 80)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MovieHeaderBox);
+ assert_eq!(stream.head.size, 120);
+ let parsed = super::read_mvhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, 5678);
+}
+
+#[test]
+fn read_mvhd_invalid_timescale() {
+ let mut stream = make_fullbox(BoxSize::Short(120), b"mvhd", 1, |s| {
+ s.B64(0).B64(0).B32(0).B64(5678).append_repeated(0, 80)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MovieHeaderBox);
+ assert_eq!(stream.head.size, 120);
+ let r = super::parse_mvhd(&mut stream);
+ assert!(r.is_err());
+}
+
+#[test]
+fn read_mvhd_unknown_duration() {
+ let mut stream = make_fullbox(BoxSize::Short(108), b"mvhd", 0, |s| {
+ s.B32(0)
+ .B32(0)
+ .B32(1234)
+ .B32(::std::u32::MAX)
+ .append_repeated(0, 80)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MovieHeaderBox);
+ assert_eq!(stream.head.size, 108);
+ let parsed = super::read_mvhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, ::std::u64::MAX);
+}
+
+#[test]
+fn read_mvhd_v0_trailing_data() {
+ let mut stream = make_fullbox(BoxSize::Short(110), b"mvhd", 0, |s| {
+ s.B32(0)
+ .B32(0)
+ .B32(1234)
+ .B32(5678)
+ .append_repeated(0, 80)
+ .B16(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::MovieHeaderBox);
+ assert_eq!(stream.head.size, 110);
+ let parsed = super::read_mvhd(&mut stream).unwrap();
+ assert_eq!(parsed.timescale, 1234);
+ assert_eq!(parsed.duration, 5678);
+}
+
+#[test]
+fn read_vpcc_version_0() {
+ let data_length = 12u16;
+ let mut stream = make_fullbox(BoxSize::Auto, b"vpcC", 0, |s| {
+ s.B8(2)
+ .B8(0)
+ .B8(0x82)
+ .B8(0)
+ .B16(data_length)
+ .append_repeated(42, data_length as usize)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::VPCodecConfigurationBox);
+ let r = super::read_vpcc(&mut stream);
+ assert!(r.is_ok());
+}
+
+// TODO: it'd be better to find a real sample here.
+#[test]
+#[allow(clippy::unusual_byte_groupings)] // Allow odd grouping for test readability.
+fn read_vpcc_version_1() {
+ let data_length = 12u16;
+ let mut stream = make_fullbox(BoxSize::Auto, b"vpcC", 1, |s| {
+ s.B8(2) // profile
+ .B8(0) // level
+ .B8(0b1000_011_0) // bitdepth (4 bits), chroma (3 bits), video full range (1 bit)
+ .B8(1) // color primaries
+ .B8(1) // transfer characteristics
+ .B8(1) // matrix
+ .B16(data_length)
+ .append_repeated(42, data_length as usize)
+ });
+
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::VPCodecConfigurationBox);
+ let r = super::read_vpcc(&mut stream);
+ match r {
+ Ok(vpcc) => {
+ assert_eq!(vpcc.bit_depth, 8);
+ assert_eq!(vpcc.chroma_subsampling, 3);
+ assert!(!vpcc.video_full_range_flag);
+ assert_eq!(vpcc.matrix_coefficients.unwrap(), 1);
+ }
+ _ => panic!("vpcc parsing error"),
+ }
+}
+
+#[test]
+fn read_hdlr() {
+ let mut stream = make_fullbox(BoxSize::Short(45), b"hdlr", 0, |s| {
+ s.B32(0)
+ .append_bytes(b"vide")
+ .B32(0)
+ .B32(0)
+ .B32(0)
+ .append_bytes(b"VideoHandler")
+ .B8(0) // null-terminate string
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 45);
+ let parsed = super::read_hdlr(&mut stream, ParseStrictness::Normal).unwrap();
+ assert_eq!(parsed.handler_type, b"vide");
+}
+
+#[test]
+fn read_hdlr_multiple_nul_in_name() {
+ let mut stream = make_fullbox(BoxSize::Short(45), b"hdlr", 0, |s| {
+ s.B32(0)
+ .append_bytes(b"vide")
+ .B32(0)
+ .B32(0)
+ .B32(0)
+ .append_bytes(b"Vide\0Handler")
+ .B8(0) // null-terminate string
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 45);
+ assert_eq!(
+ super::Status::from(super::read_hdlr(&mut stream, ParseStrictness::Strict)),
+ super::Status::Ok,
+ );
+}
+
+#[test]
+fn read_hdlr_short_name() {
+ let mut stream = make_fullbox(BoxSize::Short(33), b"hdlr", 0, |s| {
+ s.B32(0).append_bytes(b"vide").B32(0).B32(0).B32(0).B8(0) // null-terminate string
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 33);
+ let parsed = super::read_hdlr(&mut stream, ParseStrictness::Normal).unwrap();
+ assert_eq!(parsed.handler_type, b"vide");
+}
+
+#[test]
+fn read_hdlr_unsupported_version() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"hdlr", 1, |s| {
+ s.B32(0).append_bytes(b"vide").B32(0).B32(0).B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 32);
+ assert_eq!(
+ super::Status::from(super::read_hdlr(&mut stream, ParseStrictness::Normal)),
+ super::Status::HdlrUnsupportedVersion,
+ );
+}
+
+#[test]
+fn read_hdlr_invalid_pre_defined_field() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"hdlr", 0, |s| {
+ s.B32(1).append_bytes(b"vide").B32(0).B32(0).B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 32);
+ assert_eq!(
+ super::Status::from(super::read_hdlr(&mut stream, ParseStrictness::Strict)),
+ super::Status::HdlrPredefinedNonzero,
+ );
+}
+
+#[test]
+fn read_hdlr_invalid_reserved_field() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"hdlr", 0, |s| {
+ s.B32(0).append_bytes(b"vide").B32(0).B32(1).B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 32);
+ assert_eq!(
+ super::Status::from(super::read_hdlr(&mut stream, ParseStrictness::Strict)),
+ super::Status::HdlrReservedNonzero,
+ );
+}
+
+#[test]
+fn read_hdlr_zero_length_name() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"hdlr", 0, |s| {
+ s.B32(0).append_bytes(b"vide").B32(0).B32(0).B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 32);
+ assert_eq!(
+ super::Status::from(super::read_hdlr(&mut stream, ParseStrictness::Normal)),
+ super::Status::HdlrNameNoNul,
+ );
+}
+
+#[test]
+fn read_hdlr_zero_length_name_permissive() {
+ let mut stream = make_fullbox(BoxSize::Short(32), b"hdlr", 0, |s| {
+ s.B32(0).append_bytes(b"vide").B32(0).B32(0).B32(0)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::HandlerBox);
+ assert_eq!(stream.head.size, 32);
+ let parsed = super::read_hdlr(&mut stream, ParseStrictness::Permissive).unwrap();
+ assert_eq!(parsed.handler_type, b"vide");
+}
+
+fn flac_streaminfo() -> Vec<u8> {
+ vec![
+ 0x10, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x11, 0x00, 0x38, 0x32, 0x0a, 0xc4, 0x42, 0xf0, 0x00,
+ 0xc9, 0xdf, 0xae, 0xb5, 0x66, 0xfc, 0x02, 0x15, 0xa3, 0xb1, 0x54, 0x61, 0x47, 0x0f, 0xfb,
+ 0x05, 0x00, 0x33, 0xad,
+ ]
+}
+
+#[test]
+fn read_flac() {
+ let mut stream = make_box(BoxSize::Auto, b"fLaC", |s| {
+ s.append_repeated(0, 6) // reserved
+ .B16(1) // data reference index
+ .B32(0) // reserved
+ .B32(0) // reserved
+ .B16(2) // channel count
+ .B16(16) // bits per sample
+ .B16(0) // pre_defined
+ .B16(0) // reserved
+ .B32(44100 << 16) // Sample rate
+ .append_bytes(
+ &make_dfla(
+ FlacBlockType::StreamInfo,
+ true,
+ &flac_streaminfo(),
+ FlacBlockLength::Correct,
+ )
+ .into_inner(),
+ )
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let r = super::read_audio_sample_entry(&mut stream);
+ assert!(r.is_ok());
+}
+
+#[derive(Clone, Copy)]
+enum FlacBlockType {
+ StreamInfo = 0,
+ _Padding = 1,
+ _Application = 2,
+ _Seektable = 3,
+ _Comment = 4,
+ _Cuesheet = 5,
+ _Picture = 6,
+ _Reserved,
+ _Invalid = 127,
+}
+
+enum FlacBlockLength {
+ Correct,
+ Incorrect(usize),
+}
+
+fn make_dfla(
+ block_type: FlacBlockType,
+ last: bool,
+ data: &[u8],
+ data_length: FlacBlockLength,
+) -> Cursor<Vec<u8>> {
+ assert!(data.len() < 1 << 24);
+ make_fullbox(BoxSize::Auto, b"dfLa", 0, |s| {
+ let flag = u32::from(last);
+ let size = match data_length {
+ FlacBlockLength::Correct => (data.len() as u32) & 0x00ff_ffff,
+ FlacBlockLength::Incorrect(size) => {
+ assert!(size < 1 << 24);
+ (size as u32) & 0x00ff_ffff
+ }
+ };
+ let block_type = (block_type as u32) & 0x7f;
+ s.B32(flag << 31 | block_type << 24 | size)
+ .append_bytes(data)
+ })
+}
+
+#[test]
+fn read_dfla() {
+ let mut stream = make_dfla(
+ FlacBlockType::StreamInfo,
+ true,
+ &flac_streaminfo(),
+ FlacBlockLength::Correct,
+ );
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::FLACSpecificBox);
+ let dfla = super::read_dfla(&mut stream).unwrap();
+ assert_eq!(dfla.version, 0);
+}
+
+#[test]
+fn long_flac_metadata() {
+ let streaminfo = flac_streaminfo();
+ let mut stream = make_dfla(
+ FlacBlockType::StreamInfo,
+ true,
+ &streaminfo,
+ FlacBlockLength::Incorrect(streaminfo.len() + 4),
+ );
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::FLACSpecificBox);
+ let r = super::read_dfla(&mut stream);
+ assert!(r.is_err());
+}
+
+#[test]
+fn read_opus() {
+ let mut stream = make_box(BoxSize::Auto, b"Opus", |s| {
+ s.append_repeated(0, 6)
+ .B16(1) // data reference index
+ .B32(0)
+ .B32(0)
+ .B16(2) // channel count
+ .B16(16) // bits per sample
+ .B16(0)
+ .B16(0)
+ .B32(48000 << 16) // Sample rate is always 48 kHz for Opus.
+ .append_bytes(&make_dops().into_inner())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let r = super::read_audio_sample_entry(&mut stream);
+ assert!(r.is_ok());
+}
+
+fn make_dops() -> Cursor<Vec<u8>> {
+ make_box(BoxSize::Auto, b"dOps", |s| {
+ s.B8(0) // version
+ .B8(2) // channel count
+ .B16(348) // pre-skip
+ .B32(44100) // original sample rate
+ .B16(0) // gain
+ .B8(0) // channel mapping
+ })
+}
+
+#[test]
+fn read_dops() {
+ let mut stream = make_dops();
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ assert_eq!(stream.head.name, BoxType::OpusSpecificBox);
+ let r = super::read_dops(&mut stream);
+ assert!(r.is_ok());
+}
+
+#[test]
+fn serialize_opus_header() {
+ let opus = super::OpusSpecificBox {
+ version: 0,
+ output_channel_count: 1,
+ pre_skip: 342,
+ input_sample_rate: 24000,
+ output_gain: 0,
+ channel_mapping_family: 0,
+ channel_mapping_table: None,
+ };
+ let mut v = Vec::<u8>::new();
+ super::serialize_opus_header(&opus, &mut v).unwrap();
+ assert_eq!(v.len(), 19);
+ assert_eq!(
+ v,
+ vec![
+ 0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64, 0x01, 0x01, 0x56, 0x01, 0xc0, 0x5d,
+ 0x00, 0x00, 0x00, 0x00, 0x00,
+ ]
+ );
+ let opus = super::OpusSpecificBox {
+ version: 0,
+ output_channel_count: 6,
+ pre_skip: 152,
+ input_sample_rate: 48000,
+ output_gain: 0,
+ channel_mapping_family: 1,
+ channel_mapping_table: Some(super::ChannelMappingTable {
+ stream_count: 4,
+ coupled_count: 2,
+ channel_mapping: vec![0, 4, 1, 2, 3, 5].into(),
+ }),
+ };
+ let mut v = Vec::<u8>::new();
+ super::serialize_opus_header(&opus, &mut v).unwrap();
+ assert_eq!(v.len(), 27);
+ assert_eq!(
+ v,
+ vec![
+ 0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64, 0x01, 0x06, 0x98, 0x00, 0x80, 0xbb,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x02, 0x00, 0x04, 0x01, 0x02, 0x03, 0x05,
+ ]
+ );
+}
+
+#[test]
+fn read_alac() {
+ let mut stream = make_box(BoxSize::Auto, b"alac", |s| {
+ s.append_repeated(0, 6) // reserved
+ .B16(1) // data reference index
+ .B32(0) // reserved
+ .B32(0) // reserved
+ .B16(2) // channel count
+ .B16(16) // bits per sample
+ .B16(0) // pre_defined
+ .B16(0) // reserved
+ .B32(44100 << 16) // Sample rate
+ .append_bytes(
+ &make_fullbox(BoxSize::Auto, b"alac", 0, |s| s.append_bytes(&[0xfa; 24]))
+ .into_inner(),
+ )
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let r = super::read_audio_sample_entry(&mut stream);
+ assert!(r.is_ok());
+}
+
+#[test]
+fn esds_limit() {
+ let mut stream = make_box(BoxSize::Auto, b"mp4a", |s| {
+ s.append_repeated(0, 6)
+ .B16(1)
+ .B32(0)
+ .B32(0)
+ .B16(2)
+ .B16(16)
+ .B16(0)
+ .B16(0)
+ .B32(48000 << 16)
+ .B32(8)
+ .append_bytes(b"esds")
+ .append_repeated(0, 4)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ match super::read_audio_sample_entry(&mut stream) {
+ Err(Error::UnexpectedEOF) => (),
+ Ok(_) => panic!("expected an error result"),
+ _ => panic!("expected a different error result"),
+ }
+}
+
+#[test]
+fn read_elst_zero_entries() {
+ let mut stream = make_fullbox(BoxSize::Auto, b"elst", 0, |s| s.B32(0).B16(12).B16(34));
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ match super::read_elst(&mut stream) {
+ Ok(elst) => assert_eq!(elst.edits.len(), 0),
+ _ => panic!("expected no error"),
+ }
+}
+
+fn make_elst() -> Cursor<Vec<u8>> {
+ make_fullbox(BoxSize::Auto, b"elst", 1, |s| {
+ s.B32(1)
+ // first entry
+ .B64(1234) // duration
+ .B64(0xffff_ffff_ffff_ffff) // time
+ .B16(12) // rate integer
+ .B16(34) // rate fraction
+ })
+}
+
+#[test]
+fn read_edts_bogus() {
+ // First edit list entry has a media_time of -1, so we expect a second
+ // edit list entry to be present to provide a valid media_time.
+ // Bogus edts are ignored.
+ let mut stream = make_box(BoxSize::Auto, b"edts", |s| {
+ s.append_bytes(&make_elst().into_inner())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let mut track = super::Track::new(0);
+ match super::read_edts(&mut stream, &mut track) {
+ Ok(_) => {
+ assert_eq!(track.media_time, None);
+ assert_eq!(track.empty_duration, None);
+ }
+ _ => panic!("expected no error"),
+ }
+}
+
+#[test]
+fn skip_padding_in_boxes() {
+ // Padding data could be added in the end of these boxes. Parser needs to skip
+ // them instead of returning error.
+ let box_names = vec![b"stts", b"stsc", b"stsz", b"stco", b"co64", b"stss"];
+
+ for name in box_names {
+ let mut stream = make_fullbox(BoxSize::Auto, name, 1, |s| {
+ s.append_repeated(0, 100) // add padding data
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ match name {
+ b"stts" => {
+ super::read_stts(&mut stream).expect("fail to skip padding: stts");
+ }
+ b"stsc" => {
+ super::read_stsc(&mut stream).expect("fail to skip padding: stsc");
+ }
+ b"stsz" => {
+ super::read_stsz(&mut stream).expect("fail to skip padding: stsz");
+ }
+ b"stco" => {
+ super::read_stco(&mut stream).expect("fail to skip padding: stco");
+ }
+ b"co64" => {
+ super::read_co64(&mut stream).expect("fail to skip padding: co64");
+ }
+ b"stss" => {
+ super::read_stss(&mut stream).expect("fail to skip padding: stss");
+ }
+ _ => (),
+ }
+ }
+}
+
+#[test]
+fn skip_padding_in_stsd() {
+ // Padding data could be added in the end of stsd boxes. Parser needs to skip
+ // them instead of returning error.
+ let avc = make_box(BoxSize::Auto, b"avc1", |s| {
+ s.append_repeated(0, 6)
+ .B16(1)
+ .append_repeated(0, 16)
+ .B16(320)
+ .B16(240)
+ .append_repeated(0, 14)
+ .append_repeated(0, 32)
+ .append_repeated(0, 4)
+ .B32(0xffff_ffff)
+ .append_bytes(b"avcC")
+ .append_repeated(0, 100)
+ })
+ .into_inner();
+ let mut stream = make_fullbox(BoxSize::Auto, b"stsd", 0, |s| {
+ s.B32(1)
+ .append_bytes(avc.as_slice())
+ .append_repeated(0, 100) // add padding data
+ });
+
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ super::read_stsd(&mut stream, &super::Track::new(0)).expect("fail to skip padding: stsd");
+}
+
+#[test]
+fn read_qt_wave_atom() {
+ let esds = make_fullbox(BoxSize::Auto, b"esds", 0, |s| {
+ s.B8(0x03) // elementary stream descriptor tag
+ .B8(0x12) // esds length
+ .append_repeated(0, 2)
+ .B8(0x00) // flags
+ .B8(0x04) // decoder config descriptor tag
+ .B8(0x0d) // dcds length
+ .B8(0x6b) // mp3
+ .append_repeated(0, 12)
+ })
+ .into_inner();
+ let chan = make_box(BoxSize::Auto, b"chan", |s| {
+ s.append_repeated(0, 10) // we don't care its data.
+ })
+ .into_inner();
+ let wave = make_box(BoxSize::Auto, b"wave", |s| s.append_bytes(esds.as_slice())).into_inner();
+ let mut stream = make_box(BoxSize::Auto, b"mp4a", |s| {
+ s.append_repeated(0, 6)
+ .B16(1) // data_reference_count
+ .B16(1) // verion: qt -> 1
+ .append_repeated(0, 6)
+ .B16(2)
+ .B16(16)
+ .append_repeated(0, 4)
+ .B32(48000 << 16)
+ .append_repeated(0, 16)
+ .append_bytes(wave.as_slice())
+ .append_bytes(chan.as_slice())
+ });
+
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let sample_entry =
+ super::read_audio_sample_entry(&mut stream).expect("fail to read qt wave atom");
+ match sample_entry {
+ super::SampleEntry::Audio(sample_entry) => {
+ assert_eq!(sample_entry.codec_type, super::CodecType::MP3)
+ }
+ _ => panic!("fail to read audio sample enctry"),
+ }
+}
+
+#[test]
+fn read_descriptor_80() {
+ let aac_esds = vec![
+ 0x03, 0x80, 0x80, 0x80, 0x22, 0x00, 0x02, 0x00, 0x04, 0x80, 0x80, 0x80, 0x17, 0x40, 0x15,
+ 0x00, 0x00, 0x00, 0x00, 0x03, 0x22, 0xBC, 0x00, 0x01, 0xF5, 0x83, 0x05, 0x80, 0x80, 0x80,
+ 0x02, 0x11, 0x90, 0x06, 0x80, 0x80, 0x80, 0x01, 0x02,
+ ];
+ let aac_dc_descriptor = &aac_esds[31..33];
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(aac_esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let es = super::read_esds(&mut stream).unwrap();
+
+ assert_eq!(es.audio_codec, super::CodecType::AAC);
+ assert_eq!(es.audio_object_type, Some(2));
+ assert_eq!(es.extended_audio_object_type, None);
+ assert_eq!(es.audio_sample_rate, Some(48000));
+ assert_eq!(es.audio_channel_count, Some(2));
+ assert_eq!(es.codec_esds, aac_esds);
+ assert_eq!(es.decoder_specific_data, aac_dc_descriptor);
+}
+
+#[test]
+fn read_esds() {
+ let aac_esds = vec![
+ 0x03, 0x24, 0x00, 0x00, 0x00, 0x04, 0x1c, 0x40, 0x15, 0x00, 0x12, 0x00, 0x00, 0x01, 0xf4,
+ 0x00, 0x00, 0x01, 0xf4, 0x00, 0x05, 0x0d, 0x13, 0x00, 0x05, 0x88, 0x05, 0x00, 0x48, 0x21,
+ 0x10, 0x00, 0x56, 0xe5, 0x98, 0x06, 0x01, 0x02,
+ ];
+ let aac_dc_descriptor = &aac_esds[22..35];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(aac_esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let es = super::read_esds(&mut stream).unwrap();
+
+ assert_eq!(es.audio_codec, super::CodecType::AAC);
+ assert_eq!(es.audio_object_type, Some(2));
+ assert_eq!(es.extended_audio_object_type, None);
+ assert_eq!(es.audio_sample_rate, Some(24000));
+ assert_eq!(es.audio_channel_count, Some(6));
+ assert_eq!(es.codec_esds, aac_esds);
+ assert_eq!(es.decoder_specific_data, aac_dc_descriptor);
+}
+
+#[test]
+fn read_esds_aac_type5() {
+ let aac_esds = vec![
+ 0x03, 0x80, 0x80, 0x80, 0x2F, 0x00, 0x00, 0x00, 0x04, 0x80, 0x80, 0x80, 0x21, 0x40, 0x15,
+ 0x00, 0x15, 0x00, 0x00, 0x03, 0xED, 0xAA, 0x00, 0x03, 0x6B, 0x00, 0x05, 0x80, 0x80, 0x80,
+ 0x0F, 0x2B, 0x01, 0x88, 0x02, 0xC4, 0x04, 0x90, 0x2C, 0x10, 0x8C, 0x80, 0x00, 0x00, 0xED,
+ 0x40, 0x06, 0x80, 0x80, 0x80, 0x01, 0x02,
+ ];
+
+ let aac_dc_descriptor = &aac_esds[31..46];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(aac_esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let es = super::read_esds(&mut stream).unwrap();
+
+ assert_eq!(es.audio_codec, super::CodecType::AAC);
+ assert_eq!(es.audio_object_type, Some(2));
+ assert_eq!(es.extended_audio_object_type, Some(5));
+ assert_eq!(es.audio_sample_rate, Some(24000));
+ assert_eq!(es.audio_channel_count, Some(8));
+ assert_eq!(es.codec_esds, aac_esds);
+ assert_eq!(es.decoder_specific_data, aac_dc_descriptor);
+}
+
+#[test]
+fn read_esds_mpeg2_aac_lc() {
+ // Recognize MPEG-2 AAC LC (ISO 13818-7) object type as AAC.
+ // Extracted from BMO #1722497 sdasdasdasd_001.mp4 using Bento4.
+ // "mp4extract --payload-only moov/trak[1]/mdia/minf/stbl/stsd/mp4a/esds sdasdasdasd_001.mp4 /dev/stdout | xxd -i -c 15"
+ let aac_esds = vec![
+ 0x03, 0x19, 0x00, 0x00, 0x00, 0x04, 0x11, 0x67, 0x15, 0x00, 0x02, 0x38, 0x00, 0x01, 0x0f,
+ 0xd0, 0x00, 0x00, 0xf5, 0x48, 0x05, 0x02, 0x13, 0x90, 0x06, 0x01, 0x02,
+ ];
+ let aac_dc_descriptor = &aac_esds[22..24];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(aac_esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let es = super::read_esds(&mut stream).unwrap();
+
+ assert_eq!(es.audio_codec, super::CodecType::AAC);
+ assert_eq!(es.audio_object_type, Some(2));
+ assert_eq!(es.extended_audio_object_type, None);
+ assert_eq!(es.audio_sample_rate, Some(22050));
+ assert_eq!(es.audio_channel_count, Some(2));
+ assert_eq!(es.codec_esds, aac_esds);
+ assert_eq!(es.decoder_specific_data, aac_dc_descriptor);
+}
+
+#[test]
+fn read_stsd_mp4v() {
+ let mp4v = vec![
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd0, 0x01, 0xe0, 0x00, 0x48,
+ 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00,
+ 0x18, 0xff, 0xff, 0x00, 0x00, 0x00, 0x4c, 0x65, 0x73, 0x64, 0x73, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x3e, 0x00, 0x00, 0x1f, 0x04, 0x36, 0x20, 0x11, 0x01, 0x77, 0x00, 0x00, 0x03, 0xe8,
+ 0x00, 0x00, 0x03, 0xe8, 0x00, 0x05, 0x27, 0x00, 0x00, 0x01, 0xb0, 0x05, 0x00, 0x00, 0x01,
+ 0xb5, 0x0e, 0xcf, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0x86, 0xe0, 0x00,
+ 0x2e, 0xa6, 0x60, 0x16, 0xf4, 0x01, 0xf4, 0x24, 0xc8, 0x01, 0xe5, 0x16, 0x84, 0x3c, 0x14,
+ 0x63, 0x06, 0x01, 0x02,
+ ];
+ #[cfg(not(feature = "mp4v"))]
+ let esds_specific_data = &mp4v[90..];
+ #[cfg(feature = "mp4v")]
+ let esds_specific_data = &mp4v[112..151];
+ println!("esds_specific_data {esds_specific_data:?}");
+
+ let mut stream = make_box(BoxSize::Auto, b"mp4v", |s| s.append_bytes(mp4v.as_slice()));
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let sample_entry = super::read_video_sample_entry(&mut stream).unwrap();
+
+ match sample_entry {
+ super::SampleEntry::Video(v) => {
+ assert_eq!(v.codec_type, super::CodecType::MP4V);
+ assert_eq!(v.width, 720);
+ assert_eq!(v.height, 480);
+ match v.codec_specific {
+ super::VideoCodecSpecific::ESDSConfig(esds_data) => {
+ assert_eq!(esds_data.as_slice(), esds_specific_data);
+ }
+ _ => panic!("it should be ESDSConfig!"),
+ }
+ }
+ _ => panic!("it should be a video sample entry!"),
+ }
+}
+
+#[test]
+fn read_esds_one_byte_extension_descriptor() {
+ let esds = vec![
+ 0x00, 0x03, 0x80, 0x1b, 0x00, 0x00, 0x00, 0x04, 0x80, 0x12, 0x40, 0x15, 0x00, 0x06, 0x00,
+ 0x00, 0x01, 0xfe, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x05, 0x80, 0x02, 0x11, 0x90, 0x06, 0x01,
+ 0x02,
+ ];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let es = super::read_esds(&mut stream).unwrap();
+
+ assert_eq!(es.audio_codec, super::CodecType::AAC);
+ assert_eq!(es.audio_object_type, Some(2));
+ assert_eq!(es.extended_audio_object_type, None);
+ assert_eq!(es.audio_sample_rate, Some(48000));
+ assert_eq!(es.audio_channel_count, Some(2));
+}
+
+#[test]
+fn read_esds_byte_extension_descriptor() {
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .B16(0x0003)
+ .B16(0x8181) // extension byte length 0x81
+ .append_repeated(0, 0x81)
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ match super::read_esds(&mut stream) {
+ Ok(_) => (),
+ _ => panic!("fail to parse descriptor extension byte length"),
+ }
+}
+
+#[test]
+fn read_f4v_stsd() {
+ let mut stream = make_box(BoxSize::Auto, b".mp3", |s| {
+ s.append_repeated(0, 6)
+ .B16(1)
+ .B16(0)
+ .append_repeated(0, 6)
+ .B16(2)
+ .B16(16)
+ .append_repeated(0, 4)
+ .B32(48000 << 16)
+ });
+
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ let sample_entry =
+ super::read_audio_sample_entry(&mut stream).expect("failed to read f4v stsd atom");
+ match sample_entry {
+ super::SampleEntry::Audio(sample_entry) => {
+ assert_eq!(sample_entry.codec_type, super::CodecType::MP3)
+ }
+ _ => panic!("fail to read audio sample enctry"),
+ }
+}
+
+#[test]
+fn unknown_video_sample_entry() {
+ let unknown_codec = make_box(BoxSize::Auto, b"yyyy", |s| s.append_repeated(0, 16)).into_inner();
+ let mut stream = make_box(BoxSize::Auto, b"xxxx", |s| {
+ s.append_repeated(0, 6)
+ .B16(1)
+ .append_repeated(0, 16)
+ .B16(0)
+ .B16(0)
+ .append_repeated(0, 14)
+ .append_repeated(0, 32)
+ .append_repeated(0, 4)
+ .append_bytes(unknown_codec.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ match super::read_video_sample_entry(&mut stream) {
+ Ok(super::SampleEntry::Unknown) => (),
+ _ => panic!("expected a different error result"),
+ }
+}
+
+#[test]
+fn unknown_audio_sample_entry() {
+ let unknown_codec = make_box(BoxSize::Auto, b"yyyy", |s| s.append_repeated(0, 16)).into_inner();
+ let mut stream = make_box(BoxSize::Auto, b"xxxx", |s| {
+ s.append_repeated(0, 6)
+ .B16(1)
+ .B32(0)
+ .B32(0)
+ .B16(2)
+ .B16(16)
+ .B16(0)
+ .B16(0)
+ .B32(48000 << 16)
+ .append_bytes(unknown_codec.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+ match super::read_audio_sample_entry(&mut stream) {
+ Ok(super::SampleEntry::Unknown) => (),
+ _ => panic!("expected a different error result"),
+ }
+}
+
+#[test]
+fn read_esds_invalid_descriptor() {
+ // tag 0x06, 0xff, 0x7f is incorrect.
+ let esds = vec![
+ 0x03, 0x80, 0x80, 0x80, 0x22, 0x00, 0x00, 0x00, 0x04, 0x80, 0x80, 0x80, 0x14, 0x40, 0x01,
+ 0x00, 0x04, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x05, 0x80, 0x80, 0x80,
+ 0x02, 0xe8, 0x35, 0x06, 0xff, 0x7f, 0x00, 0x00,
+ ];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ match super::read_esds(&mut stream) {
+ Err(Error::InvalidData(s)) => assert_eq!(s, Status::EsdsBadDescriptor),
+ _ => panic!("unexpected result with invalid descriptor"),
+ }
+}
+
+#[test]
+fn read_esds_redundant_descriptor() {
+ // the '2' at the end is redundant data.
+ let esds = vec![
+ 3, 25, 0, 1, 0, 4, 19, 64, 21, 0, 0, 0, 0, 0, 0, 0, 0, 1, 119, 0, 5, 2, 18, 16, 6, 1, 2,
+ ];
+
+ let mut stream = make_box(BoxSize::Auto, b"esds", |s| {
+ s.B32(0) // reserved
+ .append_bytes(esds.as_slice())
+ });
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ match super::read_esds(&mut stream) {
+ Ok(esds) => assert_eq!(esds.audio_codec, super::CodecType::AAC),
+ _ => panic!("unexpected result with invalid descriptor"),
+ }
+}
+
+#[test]
+fn read_stsd_lpcm() {
+ // Extract from sample converted by ffmpeg.
+ // "ffmpeg -i ./gizmo-short.mp4 -acodec pcm_s16le -ar 96000 -vcodec copy -f mov gizmo-short.mov"
+ let lpcm = vec![
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x03, 0x00, 0x10, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x48, 0x40, 0xf7, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x7f,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x63, 0x68, 0x61, 0x6e, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x64, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ ];
+
+ let mut stream = make_box(BoxSize::Auto, b"lpcm", |s| s.append_bytes(lpcm.as_slice()));
+ let mut iter = super::BoxIter::new(&mut stream);
+ let mut stream = iter.next_box().unwrap().unwrap();
+
+ let sample_entry = super::read_audio_sample_entry(&mut stream).unwrap();
+
+ match sample_entry {
+ #[allow(clippy::float_cmp)] // The float comparison below is valid and intended.
+ super::SampleEntry::Audio(a) => {
+ assert_eq!(a.codec_type, super::CodecType::LPCM);
+ assert_eq!(a.samplerate, 96000.0);
+ assert_eq!(a.channelcount, 1);
+ match a.codec_specific {
+ super::AudioCodecSpecific::LPCM => (),
+ _ => panic!("it should be LPCM!"),
+ }
+ }
+ _ => panic!("it should be a audio sample entry!"),
+ }
+}
+
+#[test]
+fn read_to_end_() {
+ let mut src = b"1234567890".take(5);
+ let buf = src.read_into_try_vec().unwrap();
+ assert_eq!(buf.len(), 5);
+ assert_eq!(buf, b"12345".as_ref());
+}
+
+#[test]
+fn read_to_end_oom() {
+ let mut src = b"1234567890".take(std::isize::MAX.try_into().expect("isize < u64"));
+ assert!(src.read_into_try_vec().is_err());
+}
diff --git a/third_party/rust/mp4parse/src/unstable.rs b/third_party/rust/mp4parse/src/unstable.rs
new file mode 100644
index 0000000000..188dbbd731
--- /dev/null
+++ b/third_party/rust/mp4parse/src/unstable.rs
@@ -0,0 +1,541 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+use num_traits::{CheckedAdd, CheckedSub, PrimInt, Zero};
+use std::ops::{Add, Neg, Sub};
+
+use super::*;
+
+/// A zero-overhead wrapper around integer types for the sake of always
+/// requiring checked arithmetic
+#[repr(transparent)]
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct CheckedInteger<T>(pub T);
+
+impl<T> From<T> for CheckedInteger<T> {
+ fn from(i: T) -> Self {
+ Self(i)
+ }
+}
+
+// Orphan rules prevent a more general implementation, but this suffices
+impl From<CheckedInteger<i64>> for i64 {
+ fn from(checked: CheckedInteger<i64>) -> i64 {
+ checked.0
+ }
+}
+
+impl<T, U: Into<T>> Add<U> for CheckedInteger<T>
+where
+ T: CheckedAdd,
+{
+ type Output = Option<Self>;
+
+ fn add(self, other: U) -> Self::Output {
+ self.0.checked_add(&other.into()).map(Into::into)
+ }
+}
+
+impl<T, U: Into<T>> Sub<U> for CheckedInteger<T>
+where
+ T: CheckedSub,
+{
+ type Output = Option<Self>;
+
+ fn sub(self, other: U) -> Self::Output {
+ self.0.checked_sub(&other.into()).map(Into::into)
+ }
+}
+
+/// Implement subtraction of checked `u64`s returning i64
+// This is necessary for handling Mp4parseTrackInfo::media_time gracefully
+impl Sub for CheckedInteger<u64> {
+ type Output = Option<CheckedInteger<i64>>;
+
+ fn sub(self, other: Self) -> Self::Output {
+ if self >= other {
+ self.0
+ .checked_sub(other.0)
+ .and_then(|u| i64::try_from(u).ok())
+ .map(CheckedInteger)
+ } else {
+ other
+ .0
+ .checked_sub(self.0)
+ .and_then(|u| i64::try_from(u).ok())
+ .map(i64::neg)
+ .map(CheckedInteger)
+ }
+ }
+}
+
+#[test]
+fn u64_subtraction_returning_i64() {
+ // self > other
+ assert_eq!(
+ CheckedInteger(2u64) - CheckedInteger(1u64),
+ Some(CheckedInteger(1i64))
+ );
+
+ // self == other
+ assert_eq!(
+ CheckedInteger(1u64) - CheckedInteger(1u64),
+ Some(CheckedInteger(0i64))
+ );
+
+ // difference too large to store in i64
+ assert_eq!(CheckedInteger(u64::MAX) - CheckedInteger(1u64), None);
+
+ // self < other
+ assert_eq!(
+ CheckedInteger(1u64) - CheckedInteger(2u64),
+ Some(CheckedInteger(-1i64))
+ );
+
+ // difference not representable due to overflow
+ assert_eq!(CheckedInteger(1u64) - CheckedInteger(u64::MAX), None);
+}
+
+impl<T: std::cmp::PartialEq> PartialEq<T> for CheckedInteger<T> {
+ fn eq(&self, other: &T) -> bool {
+ self.0 == *other
+ }
+}
+
+/// Provides the following information about a sample in the source file:
+/// sample data offset (start and end), composition time in microseconds
+/// (start and end) and whether it is a sync sample
+#[repr(C)]
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct Indice {
+ /// The byte offset in the file where the indexed sample begins.
+ pub start_offset: CheckedInteger<u64>,
+ /// The byte offset in the file where the indexed sample ends. This is
+ /// equivalent to `start_offset` + the length in bytes of the indexed
+ /// sample. Typically this will be the `start_offset` of the next sample
+ /// in the file.
+ pub end_offset: CheckedInteger<u64>,
+ /// The time in ticks when the indexed sample should be displayed.
+ /// Analogous to the concept of presentation time stamp (pts).
+ pub start_composition: CheckedInteger<i64>,
+ /// The time in ticks when the indexed sample should stop being
+ /// displayed. Typically this would be the `start_composition` time of the
+ /// next sample if samples were ordered by composition time.
+ pub end_composition: CheckedInteger<i64>,
+ /// The time in ticks that the indexed sample should be decoded at.
+ /// Analogous to the concept of decode time stamp (dts).
+ pub start_decode: CheckedInteger<i64>,
+ /// Set if the indexed sample is a sync sample. The meaning of sync is
+ /// somewhat codec specific, but essentially amounts to if the sample is a
+ /// key frame.
+ pub sync: bool,
+}
+
+/// Create a vector of `Indice`s with the information about track samples.
+/// It uses `stsc`, `stco`, `stsz` and `stts` boxes to construct a list of
+/// every sample in the file and provides offsets which can be used to read
+/// raw sample data from the file.
+#[allow(clippy::reversed_empty_ranges)]
+pub fn create_sample_table(
+ track: &Track,
+ track_offset_time: CheckedInteger<i64>,
+) -> Option<TryVec<Indice>> {
+ let (stsc, stco, stsz, stts) = match (&track.stsc, &track.stco, &track.stsz, &track.stts) {
+ (Some(a), Some(b), Some(c), Some(d)) => (a, b, c, d),
+ _ => return None,
+ };
+
+ // According to spec, no sync table means every sample is sync sample.
+ let has_sync_table = track.stss.is_some();
+
+ let mut sample_size_iter = stsz.sample_sizes.iter();
+
+ // Get 'stsc' iterator for (chunk_id, chunk_sample_count) and calculate the sample
+ // offset address.
+
+ // With large numbers of samples, the cost of many allocations dominates,
+ // so it's worth iterating twice to allocate sample_table just once.
+ let total_sample_count = sample_to_chunk_iter(&stsc.samples, &stco.offsets)
+ .map(|(_, sample_counts)| sample_counts.to_usize())
+ .try_fold(0usize, usize::checked_add)?;
+ let mut sample_table = TryVec::with_capacity(total_sample_count).ok()?;
+
+ for i in sample_to_chunk_iter(&stsc.samples, &stco.offsets) {
+ let chunk_id = i.0 as usize;
+ let sample_counts = i.1;
+ let mut cur_position = match stco.offsets.get(chunk_id) {
+ Some(&i) => i.into(),
+ _ => return None,
+ };
+ for _ in 0..sample_counts {
+ let start_offset = cur_position;
+ let end_offset = match (stsz.sample_size, sample_size_iter.next()) {
+ (_, Some(t)) => (start_offset + *t)?,
+ (t, _) if t > 0 => (start_offset + t)?,
+ _ => 0.into(),
+ };
+ if end_offset == 0 {
+ return None;
+ }
+ cur_position = end_offset;
+
+ sample_table
+ .push(Indice {
+ start_offset,
+ end_offset,
+ sync: !has_sync_table,
+ ..Default::default()
+ })
+ .ok()?;
+ }
+ }
+
+ // Mark the sync sample in sample_table according to 'stss'.
+ if let Some(ref v) = track.stss {
+ for iter in &v.samples {
+ match iter
+ .checked_sub(&1)
+ .and_then(|idx| sample_table.get_mut(idx as usize))
+ {
+ Some(elem) => elem.sync = true,
+ _ => return None,
+ }
+ }
+ }
+
+ let ctts_iter = track.ctts.as_ref().map(|v| v.samples.as_slice().iter());
+
+ let mut ctts_offset_iter = TimeOffsetIterator {
+ cur_sample_range: (0..0),
+ cur_offset: 0,
+ ctts_iter,
+ track_id: track.id,
+ };
+
+ let mut stts_iter = TimeToSampleIterator {
+ cur_sample_count: (0..0),
+ cur_sample_delta: 0,
+ stts_iter: stts.samples.as_slice().iter(),
+ track_id: track.id,
+ };
+
+ // sum_delta is the sum of stts_iter delta.
+ // According to spec:
+ // decode time => DT(n) = DT(n-1) + STTS(n)
+ // composition time => CT(n) = DT(n) + CTTS(n)
+ // Note:
+ // composition time needs to add the track offset time from 'elst' table.
+ let mut sum_delta = TrackScaledTime::<i64>(0, track.id);
+ for sample in sample_table.as_mut_slice() {
+ let decode_time = sum_delta;
+ sum_delta = (sum_delta + stts_iter.next_delta())?;
+
+ // ctts_offset is the current sample offset time.
+ let ctts_offset = ctts_offset_iter.next_offset_time();
+
+ let start_composition = decode_time + ctts_offset;
+
+ let end_composition = sum_delta + ctts_offset;
+
+ let start_decode = decode_time;
+
+ sample.start_composition = CheckedInteger(track_offset_time.0 + start_composition?.0);
+ sample.end_composition = CheckedInteger(track_offset_time.0 + end_composition?.0);
+ sample.start_decode = CheckedInteger(start_decode.0);
+ }
+
+ // Correct composition end time due to 'ctts' causes composition time re-ordering.
+ //
+ // Composition end time is not in specification. However, gecko needs it, so we need to
+ // calculate to correct the composition end time.
+ if !sample_table.is_empty() {
+ // Create an index table refers to sample_table and sorted by start_composisiton time.
+ let mut sort_table = TryVec::with_capacity(sample_table.len()).ok()?;
+
+ for i in 0..sample_table.len() {
+ sort_table.push(i).ok()?;
+ }
+
+ sort_table.sort_by_key(|i| match sample_table.get(*i) {
+ Some(v) => v.start_composition,
+ _ => 0.into(),
+ });
+
+ for indices in sort_table.windows(2) {
+ if let [current_index, peek_index] = *indices {
+ let next_start_composition_time = sample_table[peek_index].start_composition;
+ let sample = &mut sample_table[current_index];
+ sample.end_composition = next_start_composition_time;
+ }
+ }
+ }
+
+ Some(sample_table)
+}
+
+// Convert a 'ctts' compact table to full table by iterator,
+// (sample_with_the_same_offset_count, offset) => (offset), (offset), (offset) ...
+//
+// For example:
+// (2, 10), (4, 9) into (10, 10, 9, 9, 9, 9) by calling next_offset_time().
+struct TimeOffsetIterator<'a> {
+ cur_sample_range: std::ops::Range<u32>,
+ cur_offset: i64,
+ ctts_iter: Option<std::slice::Iter<'a, TimeOffset>>,
+ track_id: usize,
+}
+
+impl<'a> Iterator for TimeOffsetIterator<'a> {
+ type Item = i64;
+
+ #[allow(clippy::reversed_empty_ranges)]
+ fn next(&mut self) -> Option<i64> {
+ let has_sample = self.cur_sample_range.next().or_else(|| {
+ // At end of current TimeOffset, find the next TimeOffset.
+ let iter = match self.ctts_iter {
+ Some(ref mut v) => v,
+ _ => return None,
+ };
+ let offset_version;
+ self.cur_sample_range = match iter.next() {
+ Some(v) => {
+ offset_version = v.time_offset;
+ 0..v.sample_count
+ }
+ _ => {
+ offset_version = TimeOffsetVersion::Version0(0);
+ 0..0
+ }
+ };
+
+ self.cur_offset = match offset_version {
+ TimeOffsetVersion::Version0(i) => i64::from(i),
+ TimeOffsetVersion::Version1(i) => i64::from(i),
+ };
+
+ self.cur_sample_range.next()
+ });
+
+ has_sample.and(Some(self.cur_offset))
+ }
+}
+
+impl<'a> TimeOffsetIterator<'a> {
+ fn next_offset_time(&mut self) -> TrackScaledTime<i64> {
+ match self.next() {
+ Some(v) => TrackScaledTime::<i64>(v, self.track_id),
+ _ => TrackScaledTime::<i64>(0, self.track_id),
+ }
+ }
+}
+
+// Convert 'stts' compact table to full table by iterator,
+// (sample_count_with_the_same_time, time) => (time, time, time) ... repeats
+// sample_count_with_the_same_time.
+//
+// For example:
+// (2, 3000), (1, 2999) to (3000, 3000, 2999).
+struct TimeToSampleIterator<'a> {
+ cur_sample_count: std::ops::Range<u32>,
+ cur_sample_delta: u32,
+ stts_iter: std::slice::Iter<'a, Sample>,
+ track_id: usize,
+}
+
+impl<'a> Iterator for TimeToSampleIterator<'a> {
+ type Item = u32;
+
+ #[allow(clippy::reversed_empty_ranges)]
+ fn next(&mut self) -> Option<u32> {
+ let has_sample = self.cur_sample_count.next().or_else(|| {
+ self.cur_sample_count = match self.stts_iter.next() {
+ Some(v) => {
+ self.cur_sample_delta = v.sample_delta;
+ 0..v.sample_count
+ }
+ _ => 0..0,
+ };
+
+ self.cur_sample_count.next()
+ });
+
+ has_sample.and(Some(self.cur_sample_delta))
+ }
+}
+
+impl<'a> TimeToSampleIterator<'a> {
+ fn next_delta(&mut self) -> TrackScaledTime<i64> {
+ match self.next() {
+ Some(v) => TrackScaledTime::<i64>(i64::from(v), self.track_id),
+ _ => TrackScaledTime::<i64>(0, self.track_id),
+ }
+ }
+}
+
+// Convert 'stco' compact table to full table by iterator.
+// (start_chunk_num, sample_number) => (start_chunk_num, sample_number),
+// (start_chunk_num + 1, sample_number),
+// (start_chunk_num + 2, sample_number),
+// ...
+// (next start_chunk_num, next sample_number),
+// ...
+//
+// For example:
+// (1, 5), (5, 10), (9, 2) => (1, 5), (2, 5), (3, 5), (4, 5), (5, 10), (6, 10),
+// (7, 10), (8, 10), (9, 2)
+fn sample_to_chunk_iter<'a>(
+ stsc_samples: &'a TryVec<SampleToChunk>,
+ stco_offsets: &'a TryVec<u64>,
+) -> SampleToChunkIterator<'a> {
+ SampleToChunkIterator {
+ chunks: (0..0),
+ sample_count: 0,
+ stsc_peek_iter: stsc_samples.as_slice().iter().peekable(),
+ remain_chunk_count: stco_offsets
+ .len()
+ .try_into()
+ .expect("stco.entry_count is u32"),
+ }
+}
+
+struct SampleToChunkIterator<'a> {
+ chunks: std::ops::Range<u32>,
+ sample_count: u32,
+ stsc_peek_iter: std::iter::Peekable<std::slice::Iter<'a, SampleToChunk>>,
+ remain_chunk_count: u32, // total chunk number from 'stco'.
+}
+
+impl<'a> Iterator for SampleToChunkIterator<'a> {
+ type Item = (u32, u32);
+
+ fn next(&mut self) -> Option<(u32, u32)> {
+ let has_chunk = self.chunks.next().or_else(|| {
+ self.chunks = self.locate();
+ self.remain_chunk_count
+ .checked_sub(
+ self.chunks
+ .len()
+ .try_into()
+ .expect("len() of a Range<u32> must fit in u32"),
+ )
+ .and_then(|res| {
+ self.remain_chunk_count = res;
+ self.chunks.next()
+ })
+ });
+
+ has_chunk.map(|id| (id, self.sample_count))
+ }
+}
+
+impl<'a> SampleToChunkIterator<'a> {
+ #[allow(clippy::reversed_empty_ranges)]
+ fn locate(&mut self) -> std::ops::Range<u32> {
+ loop {
+ return match (self.stsc_peek_iter.next(), self.stsc_peek_iter.peek()) {
+ (Some(next), Some(peek)) if next.first_chunk == peek.first_chunk => {
+ // Invalid entry, skip it and will continue searching at
+ // next loop iteration.
+ continue;
+ }
+ (Some(next), Some(peek)) if next.first_chunk > 0 && peek.first_chunk > 0 => {
+ self.sample_count = next.samples_per_chunk;
+ (next.first_chunk - 1)..(peek.first_chunk - 1)
+ }
+ (Some(next), None) if next.first_chunk > 0 => {
+ self.sample_count = next.samples_per_chunk;
+ // Total chunk number in 'stsc' could be different to 'stco',
+ // there could be more chunks at the last 'stsc' record.
+ match next.first_chunk.checked_add(self.remain_chunk_count) {
+ Some(r) => (next.first_chunk - 1)..r - 1,
+ _ => 0..0,
+ }
+ }
+ _ => 0..0,
+ };
+ }
+ }
+}
+
+/// Calculate numerator * scale / denominator, if possible.
+///
+/// Applying the associativity of integer arithmetic, we divide first
+/// and add the remainder after multiplying each term separately
+/// to preserve precision while leaving more headroom. That is,
+/// (n * s) / d is split into floor(n / d) * s + (n % d) * s / d.
+///
+/// Return None on overflow or if the denominator is zero.
+pub fn rational_scale<T, S>(numerator: T, denominator: T, scale2: S) -> Option<T>
+where
+ T: PrimInt + Zero,
+ S: PrimInt,
+{
+ if denominator.is_zero() {
+ return None;
+ }
+
+ let integer = numerator / denominator;
+ let remainder = numerator % denominator;
+ num_traits::cast(scale2).and_then(|s| match integer.checked_mul(&s) {
+ Some(integer) => remainder
+ .checked_mul(&s)
+ .and_then(|remainder| (remainder / denominator).checked_add(&integer)),
+ None => None,
+ })
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Microseconds<T>(pub T);
+
+/// Convert `time` in media's global (mvhd) timescale to microseconds,
+/// using provided `MediaTimeScale`
+pub fn media_time_to_us(time: MediaScaledTime, scale: MediaTimeScale) -> Option<Microseconds<u64>> {
+ let microseconds_per_second = 1_000_000;
+ rational_scale(time.0, scale.0, microseconds_per_second).map(Microseconds)
+}
+
+/// Convert `time` in track's local (mdhd) timescale to microseconds,
+/// using provided `TrackTimeScale<T>`
+pub fn track_time_to_us<T>(
+ time: TrackScaledTime<T>,
+ scale: TrackTimeScale<T>,
+) -> Option<Microseconds<T>>
+where
+ T: PrimInt + Zero,
+{
+ assert_eq!(time.1, scale.1);
+ let microseconds_per_second = 1_000_000;
+ rational_scale(time.0, scale.0, microseconds_per_second).map(Microseconds)
+}
+
+#[test]
+fn rational_scale_overflow() {
+ assert_eq!(rational_scale::<u64, u64>(17, 3, 1000), Some(5666));
+ let large = 0x4000_0000_0000_0000;
+ assert_eq!(rational_scale::<u64, u64>(large, 2, 2), Some(large));
+ assert_eq!(rational_scale::<u64, u64>(large, 4, 4), Some(large));
+ assert_eq!(rational_scale::<u64, u64>(large, 2, 8), None);
+ assert_eq!(rational_scale::<u64, u64>(large, 8, 4), Some(large / 2));
+ assert_eq!(rational_scale::<u64, u64>(large + 1, 4, 4), Some(large + 1));
+ assert_eq!(rational_scale::<u64, u64>(large, 40, 1000), None);
+}
+
+#[test]
+fn media_time_overflow() {
+ let scale = MediaTimeScale(90000);
+ let duration = MediaScaledTime(9_007_199_254_710_000);
+ assert_eq!(
+ media_time_to_us(duration, scale),
+ Some(Microseconds(100_079_991_719_000_000u64))
+ );
+}
+
+#[test]
+fn track_time_overflow() {
+ let scale = TrackTimeScale(44100u64, 0);
+ let duration = TrackScaledTime(4_413_527_634_807_900u64, 0);
+ assert_eq!(
+ track_time_to_us(duration, scale),
+ Some(Microseconds(100_079_991_719_000_000u64))
+ );
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-14 18:13:24 +0000