| // Copyright 2024 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| use crate::decoder::gainmap::GainMapMetadata; |
| use crate::decoder::track::*; |
| use crate::decoder::Extent; |
| use crate::decoder::GenericIO; |
| use crate::image::YuvRange; |
| use crate::image::MAX_PLANE_COUNT; |
| use crate::internal_utils::stream::*; |
| use crate::internal_utils::*; |
| use crate::utils::clap::CleanAperture; |
| use crate::*; |
| |
| #[derive(Debug, PartialEq)] |
| pub enum BoxSize { |
| FixedSize(usize), // In bytes, header exclusive. |
| UntilEndOfStream, // The box goes on until the end of the input stream. |
| } |
| |
| #[derive(Debug)] |
| struct BoxHeader { |
| size: BoxSize, |
| box_type: String, |
| } |
| |
| impl BoxHeader { |
| fn size(&self) -> usize { |
| match self.size { |
| BoxSize::FixedSize(size) => size, // not reached. |
| BoxSize::UntilEndOfStream => 0, |
| } |
| } |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct FileTypeBox { |
| pub major_brand: String, |
| // minor_version "is informative only" (section 4.3.1 of ISO/IEC 14496-12) |
| compatible_brands: Vec<String>, |
| } |
| |
| impl FileTypeBox { |
| fn has_brand(&self, brand: &str) -> bool { |
| // As of 2024, section 4.3.1 of ISO/IEC 14496-12 does not explictly say that the file is |
| // compliant with the specification defining the major brand, but "the major_brand should be |
| // repeated in the compatible_brands". Later versions of the specification may explicitly |
| // consider the major brand as one of the compatible brands, even if not repeated. |
| if self.major_brand.as_str() == brand { |
| return true; |
| } |
| self.compatible_brands.iter().any(|x| x.as_str() == brand) |
| } |
| |
| fn has_brand_any(&self, brands: &[&str]) -> bool { |
| brands.iter().any(|brand| self.has_brand(brand)) |
| } |
| |
| pub(crate) fn is_avif(&self) -> bool { |
| // "avio" also exists but does not identify the file as AVIF on its own. See |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#image-and-image-collection-brand |
| self.has_brand_any(&[ |
| "avif", |
| "avis", |
| #[cfg(feature = "heic")] |
| "heic", |
| #[cfg(feature = "heic")] |
| "heix", |
| #[cfg(feature = "heic")] |
| "mif1", |
| ]) |
| } |
| |
| pub(crate) fn needs_meta(&self) -> bool { |
| self.has_brand_any(&[ |
| "avif", |
| #[cfg(feature = "heic")] |
| "heic", |
| #[cfg(feature = "heic")] |
| "heix", |
| #[cfg(feature = "heic")] |
| "mif1", |
| ]) |
| } |
| |
| pub(crate) fn needs_moov(&self) -> bool { |
| self.has_brand_any(&[ |
| "avis", |
| #[cfg(feature = "heic")] |
| "hevc", |
| #[cfg(feature = "heic")] |
| "msf1", |
| ]) |
| } |
| |
| pub(crate) fn has_tmap(&self) -> bool { |
| self.has_brand("tmap") |
| } |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct ItemLocationEntry { |
| pub item_id: u32, |
| pub construction_method: u8, |
| pub base_offset: u64, |
| pub extent_count: u16, |
| pub extents: Vec<Extent>, |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct ItemLocationBox { |
| offset_size: u8, |
| length_size: u8, |
| base_offset_size: u8, |
| index_size: u8, |
| pub items: Vec<ItemLocationEntry>, |
| } |
| |
| #[derive(Clone, Debug)] |
| pub struct ImageSpatialExtents { |
| pub width: u32, |
| pub height: u32, |
| } |
| |
| #[derive(Clone, Debug, Default)] |
| pub struct PixelInformation { |
| pub plane_depths: Vec<u8>, |
| } |
| |
| #[derive(Clone, Debug, Default, PartialEq)] |
| pub struct Av1CodecConfiguration { |
| pub seq_profile: u8, |
| pub seq_level_idx0: u8, |
| pub seq_tier0: u8, |
| pub high_bitdepth: bool, |
| pub twelve_bit: bool, |
| pub monochrome: bool, |
| pub chroma_subsampling_x: u8, |
| pub chroma_subsampling_y: u8, |
| pub chroma_sample_position: ChromaSamplePosition, |
| pub raw_data: Vec<u8>, |
| } |
| |
| #[derive(Clone, Debug, Default, PartialEq)] |
| pub struct HevcCodecConfiguration { |
| pub bitdepth: u8, |
| pub nal_length_size: u8, |
| pub vps: Vec<u8>, |
| pub sps: Vec<u8>, |
| pub pps: Vec<u8>, |
| } |
| |
| impl CodecConfiguration { |
| pub(crate) fn depth(&self) -> u8 { |
| match self { |
| Self::Av1(config) => match config.twelve_bit { |
| true => 12, |
| false => match config.high_bitdepth { |
| true => 10, |
| false => 8, |
| }, |
| }, |
| Self::Hevc(config) => config.bitdepth, |
| } |
| } |
| |
| pub(crate) fn pixel_format(&self) -> PixelFormat { |
| match self { |
| Self::Av1(config) => { |
| if config.monochrome { |
| PixelFormat::Yuv400 |
| } else if config.chroma_subsampling_x == 1 && config.chroma_subsampling_y == 1 { |
| PixelFormat::Yuv420 |
| } else if config.chroma_subsampling_x == 1 { |
| PixelFormat::Yuv422 |
| } else { |
| PixelFormat::Yuv444 |
| } |
| } |
| Self::Hevc(_) => { |
| // It is okay to always return Yuv420 here since that is the only format that |
| // android_mediacodec returns. |
| // TODO: b/370549923 - Identify the correct YUV subsampling type from the codec |
| // configuration data. |
| PixelFormat::Yuv420 |
| } |
| } |
| } |
| |
| pub(crate) fn chroma_sample_position(&self) -> ChromaSamplePosition { |
| match self { |
| Self::Av1(config) => config.chroma_sample_position, |
| Self::Hevc(_) => { |
| // It is okay to always return ChromaSamplePosition::default() here since that is |
| // the only format that android_mediacodec returns. |
| // TODO: b/370549923 - Identify the correct chroma sample position from the codec |
| // configuration data. |
| ChromaSamplePosition::default() |
| } |
| } |
| } |
| |
| #[cfg(feature = "android_mediacodec")] |
| pub(crate) fn raw_data(&self) -> Vec<u8> { |
| match self { |
| Self::Av1(config) => config.raw_data.clone(), |
| Self::Hevc(config) => { |
| // For HEVC, the codec specific data consists of the following 3 NAL units in |
| // order: VPS, SPS and PPS. Each unit should be preceded by a start code of |
| // "\x00\x00\x00\x01". |
| // https://developer.android.com/reference/android/media/MediaCodec#CSD |
| let mut data: Vec<u8> = Vec::new(); |
| for nal_unit in [&config.vps, &config.sps, &config.pps] { |
| // Start code. |
| data.extend_from_slice(&[0, 0, 0, 1]); |
| // Data. |
| data.extend_from_slice(&nal_unit[..]); |
| } |
| data |
| } |
| } |
| } |
| |
| pub fn profile(&self) -> u8 { |
| match self { |
| Self::Av1(config) => config.seq_profile, |
| Self::Hevc(_) => { |
| // TODO: b/370549923 - Identify the correct profile from the codec configuration |
| // data. |
| 0 |
| } |
| } |
| } |
| |
| #[cfg(feature = "android_mediacodec")] |
| pub(crate) fn nal_length_size(&self) -> u8 { |
| match self { |
| Self::Av1(_) => 0, // Unused. This function is only used for HEVC. |
| Self::Hevc(config) => config.nal_length_size, |
| } |
| } |
| |
| pub(crate) fn is_avif(&self) -> bool { |
| matches!(self, Self::Av1(_)) |
| } |
| |
| pub(crate) fn is_heic(&self) -> bool { |
| matches!(self, Self::Hevc(_)) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| pub enum ColorInformation { |
| Icc(Vec<u8>), |
| Nclx(Nclx), |
| Unknown, |
| } |
| |
| #[derive(Clone, Debug, PartialEq)] |
| pub enum CodecConfiguration { |
| Av1(Av1CodecConfiguration), |
| Hevc(HevcCodecConfiguration), |
| } |
| |
| impl Default for CodecConfiguration { |
| fn default() -> Self { |
| Self::Av1(Av1CodecConfiguration::default()) |
| } |
| } |
| |
| #[derive(Clone, Debug)] |
| pub enum ItemProperty { |
| ImageSpatialExtents(ImageSpatialExtents), |
| PixelInformation(PixelInformation), |
| CodecConfiguration(CodecConfiguration), |
| ColorInformation(ColorInformation), |
| PixelAspectRatio(PixelAspectRatio), |
| AuxiliaryType(String), |
| CleanAperture(CleanAperture), |
| ImageRotation(u8), |
| ImageMirror(u8), |
| OperatingPointSelector(u8), |
| LayerSelector(u16), |
| AV1LayeredImageIndexing([usize; 3]), |
| ContentLightLevelInformation(ContentLightLevelInformation), |
| Unknown(String), |
| } |
| |
| // Section 8.11.14 of ISO/IEC 14496-12. |
| #[derive(Debug, Default)] |
| pub struct ItemPropertyAssociation { |
| pub item_id: u32, |
| pub associations: Vec<( |
| u16, // 1-based property_index |
| bool, // essential |
| )>, |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct ItemInfo { |
| pub item_id: u32, |
| item_protection_index: u16, |
| pub item_type: String, |
| item_name: String, |
| pub content_type: String, |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct ItemPropertyBox { |
| pub properties: Vec<ItemProperty>, |
| pub associations: Vec<ItemPropertyAssociation>, |
| } |
| |
| #[derive(Debug)] |
| pub struct ItemReference { |
| // Read this reference as "{from_item_id} is a {reference_type} for {to_item_id}" |
| // (except for dimg where it is in the opposite direction). |
| pub from_item_id: u32, |
| pub to_item_id: u32, |
| pub reference_type: String, |
| pub index: u32, // 0-based index of the reference within the iref type. |
| } |
| |
| #[derive(Debug, Default)] |
| pub struct MetaBox { |
| pub iinf: Vec<ItemInfo>, |
| pub iloc: ItemLocationBox, |
| pub primary_item_id: u32, // pitm |
| pub iprp: ItemPropertyBox, |
| pub iref: Vec<ItemReference>, |
| pub idat: Vec<u8>, |
| } |
| |
| #[derive(Debug)] |
| pub struct AvifBoxes { |
| pub ftyp: FileTypeBox, |
| pub meta: MetaBox, |
| pub tracks: Vec<Track>, |
| } |
| |
| fn parse_header(stream: &mut IStream, top_level: bool) -> AvifResult<BoxHeader> { |
| // Section 4.2.2 of ISO/IEC 14496-12. |
| let start_offset = stream.offset; |
| // unsigned int(32) size; |
| let mut size = stream.read_u32()? as u64; |
| // unsigned int(32) type = boxtype; |
| let box_type = stream.read_string(4)?; |
| if size == 1 { |
| // unsigned int(64) largesize; |
| size = stream.read_u64()?; |
| } |
| if box_type == "uuid" { |
| // unsigned int(8) usertype[16] = extended_type; |
| stream.skip(16)?; |
| } |
| if size == 0 { |
| // Section 4.2.2 of ISO/IEC 14496-12. |
| // if size is 0, then this box shall be in a top-level box (i.e. not contained in another |
| // box), and be the last box in its 'file', and its payload extends to the end of that |
| // enclosing 'file'. This is normally only used for a MediaDataBox. |
| if !top_level { |
| return Err(AvifError::BmffParseFailed( |
| "non-top-level box with size 0".into(), |
| )); |
| } |
| return Ok(BoxHeader { |
| box_type, |
| size: BoxSize::UntilEndOfStream, |
| }); |
| } |
| checked_decr!(size, u64_from_usize(stream.offset - start_offset)?); |
| let size = usize_from_u64(size)?; |
| if !top_level && size > stream.bytes_left()? { |
| return Err(AvifError::BmffParseFailed("possibly truncated box".into())); |
| } |
| Ok(BoxHeader { |
| box_type, |
| size: BoxSize::FixedSize(size), |
| }) |
| } |
| |
| // Reads a truncated ftyp box. Populates as many brands as it can read. |
| fn parse_truncated_ftyp(stream: &mut IStream) -> FileTypeBox { |
| // Section 4.3.2 of ISO/IEC 14496-12. |
| // unsigned int(32) major_brand; |
| let major_brand = match stream.read_string(4) { |
| Ok(major_brand) => major_brand, |
| Err(_) => return FileTypeBox::default(), |
| }; |
| let mut compatible_brands: Vec<String> = Vec::new(); |
| // unsigned int(32) compatible_brands[]; // to end of the box |
| while stream.has_bytes_left().unwrap_or_default() { |
| match stream.read_string(4) { |
| Ok(brand) => compatible_brands.push(brand), |
| Err(_) => break, |
| } |
| } |
| FileTypeBox { |
| major_brand, |
| compatible_brands, |
| } |
| } |
| |
| fn parse_ftyp(stream: &mut IStream) -> AvifResult<FileTypeBox> { |
| // Section 4.3.2 of ISO/IEC 14496-12. |
| // unsigned int(32) major_brand; |
| let major_brand = stream.read_string(4)?; |
| // unsigned int(4) minor_version; |
| stream.skip_u32()?; |
| if stream.bytes_left()? % 4 != 0 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Box[ftyp] contains a compatible brands section that isn't divisible by 4 {}", |
| stream.bytes_left()? |
| ))); |
| } |
| let mut compatible_brands: Vec<String> = create_vec_exact(stream.bytes_left()? / 4)?; |
| // unsigned int(32) compatible_brands[]; // to end of the box |
| while stream.has_bytes_left()? { |
| compatible_brands.push(stream.read_string(4)?); |
| } |
| Ok(FileTypeBox { |
| major_brand, |
| compatible_brands, |
| }) |
| } |
| |
| fn parse_hdlr(stream: &mut IStream) -> AvifResult<String> { |
| // Section 8.4.3.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) pre_defined = 0; |
| let predefined = stream.read_u32()?; |
| if predefined != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Box[hdlr] contains a pre_defined value that is nonzero".into(), |
| )); |
| } |
| // unsigned int(32) handler_type; |
| let handler_type = stream.read_string(4)?; |
| // const unsigned int(32)[3] reserved = 0; |
| if stream.read_u32()? != 0 || stream.read_u32()? != 0 || stream.read_u32()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Box[hdlr] contains invalid reserved bits".into(), |
| )); |
| } |
| // string name; |
| // Verify that a valid string is here, but don't bother to store it: |
| // name gives a human-readable name for the track type (for debugging and inspection |
| // purposes). |
| stream.read_c_string()?; |
| Ok(handler_type) |
| } |
| |
| fn parse_iloc(stream: &mut IStream) -> AvifResult<ItemLocationBox> { |
| // Section 8.11.3.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version > 2 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Box[iloc] has an unsupported version: {version}" |
| ))); |
| } |
| let mut iloc = ItemLocationBox::default(); |
| let mut bits = stream.sub_bit_stream(2)?; |
| // unsigned int(4) offset_size; |
| iloc.offset_size = bits.read(4)? as u8; |
| // unsigned int(4) length_size; |
| iloc.length_size = bits.read(4)? as u8; |
| // unsigned int(4) base_offset_size; |
| iloc.base_offset_size = bits.read(4)? as u8; |
| iloc.index_size = if version == 1 || version == 2 { |
| // unsigned int(4) index_size; |
| bits.read(4)? as u8 |
| } else { |
| // unsigned int(4) reserved; |
| bits.skip(4)?; |
| 0 |
| }; |
| assert_eq!(bits.remaining_bits()?, 0); |
| |
| // Section 8.11.3.3 of ISO/IEC 14496-12. |
| for size in [ |
| iloc.offset_size, |
| iloc.length_size, |
| iloc.base_offset_size, |
| iloc.index_size, |
| ] { |
| if ![0u8, 4, 8].contains(&size) { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Box[iloc] has invalid size: {size}" |
| ))); |
| } |
| } |
| |
| let item_count: u32 = if version < 2 { |
| // unsigned int(16) item_count; |
| stream.read_u16()? as u32 |
| } else { |
| // unsigned int(32) item_count; |
| stream.read_u32()? |
| }; |
| for _i in 0..item_count { |
| let mut entry = ItemLocationEntry { |
| item_id: if version < 2 { |
| // unsigned int(16) item_ID; |
| stream.read_u16()? as u32 |
| } else { |
| // unsigned int(32) item_ID; |
| stream.read_u32()? |
| }, |
| ..ItemLocationEntry::default() |
| }; |
| if entry.item_id == 0 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Box[iloc] has invalid item id: {}", |
| entry.item_id |
| ))); |
| } |
| if version == 1 || version == 2 { |
| let mut bits = stream.sub_bit_stream(2)?; |
| // unsigned int(12) reserved = 0; |
| if bits.read(12)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Box[iloc] has invalid reserved bits".into(), |
| )); |
| } |
| // unsigned int(4) construction_method; |
| entry.construction_method = bits.read(4)? as u8; |
| // 0: file offset, 1: idat offset, 2: item offset. |
| if entry.construction_method != 0 && entry.construction_method != 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Box[iloc] has unknown construction_method: {}", |
| entry.construction_method |
| ))); |
| } |
| } |
| // unsigned int(16) data_reference_index; |
| stream.skip(2)?; |
| // unsigned int(base_offset_size*8) base_offset; |
| entry.base_offset = stream.read_uxx(iloc.base_offset_size)?; |
| // unsigned int(16) extent_count; |
| entry.extent_count = stream.read_u16()?; |
| for _j in 0..entry.extent_count { |
| // unsigned int(index_size*8) item_reference_index; |
| stream.skip(iloc.index_size as usize)?; // Only used for construction_method 2. |
| let extent = Extent { |
| // unsigned int(offset_size*8) extent_offset; |
| offset: stream.read_uxx(iloc.offset_size)?, |
| // unsigned int(length_size*8) extent_length; |
| size: usize_from_u64(stream.read_uxx(iloc.length_size)?)?, |
| }; |
| entry.extents.push(extent); |
| } |
| iloc.items.push(entry); |
| } |
| Ok(iloc) |
| } |
| |
| // Returns the primary item ID. |
| fn parse_pitm(stream: &mut IStream) -> AvifResult<u32> { |
| // Section 8.11.4.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version == 0 { |
| // unsigned int(16) item_ID; |
| Ok(stream.read_u16()? as u32) |
| } else { |
| // unsigned int(32) item_ID; |
| Ok(stream.read_u32()?) |
| } |
| } |
| |
| fn parse_ispe(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.3.2 of ISO/IEC 23008-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| let ispe = ImageSpatialExtents { |
| // unsigned int(32) image_width; |
| width: stream.read_u32()?, |
| // unsigned int(32) image_height; |
| height: stream.read_u32()?, |
| }; |
| Ok(ItemProperty::ImageSpatialExtents(ispe)) |
| } |
| |
| fn parse_pixi(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.6.2 of ISO/IEC 23008-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int (8) num_channels; |
| let num_channels = stream.read_u8()? as usize; |
| if num_channels == 0 || num_channels > MAX_PLANE_COUNT { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid plane count {num_channels} in pixi box" |
| ))); |
| } |
| let mut pixi = PixelInformation { |
| plane_depths: create_vec_exact(num_channels)?, |
| }; |
| for _ in 0..num_channels { |
| // unsigned int (8) bits_per_channel; |
| pixi.plane_depths.push(stream.read_u8()?); |
| if pixi.plane_depths.last().unwrap() != pixi.plane_depths.first().unwrap() { |
| return Err(AvifError::UnsupportedDepth); |
| } |
| } |
| Ok(ItemProperty::PixelInformation(pixi)) |
| } |
| |
| #[allow(non_snake_case)] |
| fn parse_av1C(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| let raw_data = stream.get_immutable_vec(stream.bytes_left()?)?; |
| // See https://aomediacodec.github.io/av1-isobmff/v1.2.0.html#av1codecconfigurationbox-syntax. |
| let mut bits = stream.sub_bit_stream(4)?; |
| // unsigned int (1) marker = 1; |
| let marker = bits.read(1)?; |
| if marker != 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid marker ({marker}) in av1C" |
| ))); |
| } |
| // unsigned int (7) version = 1; |
| let version = bits.read(7)?; |
| if version != 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid version ({version}) in av1C" |
| ))); |
| } |
| let av1C = Av1CodecConfiguration { |
| // unsigned int(3) seq_profile; |
| // unsigned int(5) seq_level_idx_0; |
| seq_profile: bits.read(3)? as u8, |
| seq_level_idx0: bits.read(5)? as u8, |
| // unsigned int(1) seq_tier_0; |
| // unsigned int(1) high_bitdepth; |
| // unsigned int(1) twelve_bit; |
| // unsigned int(1) monochrome; |
| // unsigned int(1) chroma_subsampling_x; |
| // unsigned int(1) chroma_subsampling_y; |
| // unsigned int(2) chroma_sample_position; |
| seq_tier0: bits.read(1)? as u8, |
| high_bitdepth: bits.read_bool()?, |
| twelve_bit: bits.read_bool()?, |
| monochrome: bits.read_bool()?, |
| chroma_subsampling_x: bits.read(1)? as u8, |
| chroma_subsampling_y: bits.read(1)? as u8, |
| chroma_sample_position: bits.read(2)?.into(), |
| raw_data, |
| }; |
| |
| // unsigned int(3) reserved = 0; |
| if bits.read(3)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in av1C".into(), |
| )); |
| } |
| // unsigned int(1) initial_presentation_delay_present; |
| if bits.read(1)? == 1 { |
| // unsigned int(4) initial_presentation_delay_minus_one; |
| bits.read(4)?; |
| } else { |
| // unsigned int(4) reserved = 0; |
| if bits.read(4)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in av1C".into(), |
| )); |
| } |
| } |
| assert_eq!(bits.remaining_bits()?, 0); |
| |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#av1-configuration-item-property: |
| // - Sequence Header OBUs should not be present in the AV1CodecConfigurationBox. |
| // This is ignored. |
| // - If a Sequence Header OBU is present in the AV1CodecConfigurationBox, it shall match the |
| // Sequence Header OBU in the AV1 Image Item Data. |
| // This is not enforced. |
| // - The values of the fields in the AV1CodecConfigurationBox shall match those of the |
| // Sequence Header OBU in the AV1 Image Item Data. |
| // This is not enforced (?). |
| // - Metadata OBUs, if present, shall match the values given in other item properties, such as |
| // the PixelInformationProperty or ColourInformationBox. |
| // This is not enforced. |
| |
| // unsigned int(8) configOBUs[]; |
| |
| Ok(ItemProperty::CodecConfiguration(CodecConfiguration::Av1( |
| av1C, |
| ))) |
| } |
| |
| #[allow(non_snake_case)] |
| #[cfg(feature = "heic")] |
| fn parse_hvcC(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // unsigned int(8) configurationVersion; |
| let configuration_version = stream.read_u8()?; |
| if configuration_version != 0 && configuration_version != 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Unknown configurationVersion({configuration_version}) in hvcC. Expected 0 or 1." |
| ))); |
| } |
| let mut bits = stream.sub_bit_stream(21)?; |
| // unsigned int(2) general_profile_space; |
| // unsigned int(1) general_tier_flag; |
| // unsigned int(5) general_profile_idc; |
| // unsigned int(32) general_profile_compatibility_flags; |
| // unsigned int(48) general_constraint_indicator_flags; |
| // unsigned int(8) general_level_idc; |
| // bit(4) reserved = '1111'b; |
| // unsigned int(12) min_spatial_segmentation_idc; |
| // bit(6) reserved = '111111'b; |
| // unsigned int(2) parallelismType; |
| // bit(6) reserved = '111111'b; |
| // unsigned int(2) chroma_format_idc; |
| // bit(5) reserved = '11111'b; |
| bits.skip(2 + 1 + 5 + 32 + 48 + 8 + 4 + 12 + 6 + 2 + 6 + 2 + 5)?; |
| // unsigned int(3) bit_depth_luma_minus8; |
| let bitdepth = bits.read(3)? as u8 + 8; |
| // bit(5) reserved = '11111'b; |
| // unsigned int(3) bit_depth_chroma_minus8; |
| // unsigned int(16) avgFrameRate; |
| // unsigned int(2) constantFrameRate; |
| // unsigned int(3) numTemporalLayers; |
| // unsigned int(1) temporalIdNested; |
| bits.skip(5 + 3 + 16 + 2 + 3 + 1)?; |
| // unsigned int(2) lengthSizeMinusOne; |
| let nal_length_size = 1 + bits.read(2)? as u8; |
| assert!(bits.remaining_bits()? == 0); |
| |
| // unsigned int(8) numOfArrays; |
| let num_of_arrays = stream.read_u8()?; |
| let mut vps: Vec<u8> = Vec::new(); |
| let mut sps: Vec<u8> = Vec::new(); |
| let mut pps: Vec<u8> = Vec::new(); |
| for _i in 0..num_of_arrays { |
| // unsigned int(1) array_completeness; |
| // bit(1) reserved = 0; |
| // unsigned int(6) NAL_unit_type; |
| stream.skip(1)?; |
| // unsigned int(16) numNalus; |
| let num_nalus = stream.read_u16()?; |
| for _j in 0..num_nalus { |
| // unsigned int(16) nalUnitLength; |
| let nal_unit_length = stream.read_u16()?; |
| let nal_unit = stream.get_slice(nal_unit_length as usize)?; |
| let nal_unit_type = (nal_unit[0] >> 1) & 0x3f; |
| match nal_unit_type { |
| 32 => vps = nal_unit.to_vec(), |
| 33 => sps = nal_unit.to_vec(), |
| 34 => pps = nal_unit.to_vec(), |
| _ => {} |
| } |
| } |
| } |
| Ok(ItemProperty::CodecConfiguration(CodecConfiguration::Hevc( |
| HevcCodecConfiguration { |
| bitdepth, |
| nal_length_size, |
| vps, |
| pps, |
| sps, |
| }, |
| ))) |
| } |
| |
| fn parse_colr(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 12.1.5.2 of ISO/IEC 14496-12. |
| |
| // unsigned int(32) colour_type; |
| let color_type = stream.read_string(4)?; |
| if color_type == "rICC" || color_type == "prof" { |
| if stream.bytes_left()? == 0 { |
| // Section 12.1.5.3 of ISO/IEC 14496-12: |
| // ICC_profile: an ICC profile as defined in ISO 15076-1 or ICC.1 is supplied. |
| // Section 7.2.1 of ICC.1:2010: |
| // The profile header is 128 bytes in length and contains 18 fields. |
| // So an empty ICC profile is invalid. |
| return Err(AvifError::BmffParseFailed(format!( |
| "colr box contains 0 bytes of {color_type}" |
| ))); |
| } |
| // ICC_profile; // restricted ("rICC") or unrestricted ("prof") ICC profile |
| return Ok(ItemProperty::ColorInformation(ColorInformation::Icc( |
| stream.get_slice(stream.bytes_left()?)?.to_vec(), |
| ))); |
| } |
| if color_type == "nclx" { |
| let mut nclx = Nclx { |
| // unsigned int(16) colour_primaries; |
| color_primaries: stream.read_u16()?.into(), |
| // unsigned int(16) transfer_characteristics; |
| transfer_characteristics: stream.read_u16()?.into(), |
| // unsigned int(16) matrix_coefficients; |
| matrix_coefficients: stream.read_u16()?.into(), |
| ..Nclx::default() |
| }; |
| let mut bits = stream.sub_bit_stream(1)?; |
| // unsigned int(1) full_range_flag; |
| nclx.yuv_range = if bits.read_bool()? { YuvRange::Full } else { YuvRange::Limited }; |
| // unsigned int(7) reserved = 0; |
| if bits.read(7)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "colr box contains invalid reserved bits".into(), |
| )); |
| } |
| return Ok(ItemProperty::ColorInformation(ColorInformation::Nclx(nclx))); |
| } |
| Ok(ItemProperty::ColorInformation(ColorInformation::Unknown)) |
| } |
| |
| fn parse_pasp(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 12.1.4.2 of ISO/IEC 14496-12. |
| let pasp = PixelAspectRatio { |
| // unsigned int(32) hSpacing; |
| h_spacing: stream.read_u32()?, |
| // unsigned int(32) vSpacing; |
| v_spacing: stream.read_u32()?, |
| }; |
| Ok(ItemProperty::PixelAspectRatio(pasp)) |
| } |
| |
| #[allow(non_snake_case)] |
| fn parse_auxC(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.8.2 of ISO/IEC 23008-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // string aux_type; |
| let auxiliary_type = stream.read_c_string()?; |
| // template unsigned int(8) aux_subtype[]; |
| // until the end of the box, the semantics depend on the aux_type value |
| Ok(ItemProperty::AuxiliaryType(auxiliary_type)) |
| } |
| |
| fn parse_clap(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 12.1.4.2 of ISO/IEC 14496-12. |
| let clap = CleanAperture { |
| // unsigned int(32) cleanApertureWidthN; |
| // unsigned int(32) cleanApertureWidthD; |
| width: stream.read_ufraction()?, |
| // unsigned int(32) cleanApertureHeightN; |
| // unsigned int(32) cleanApertureHeightD; |
| height: stream.read_ufraction()?, |
| // unsigned int(32) horizOffN; |
| // unsigned int(32) horizOffD; |
| horiz_off: stream.read_ufraction()?, |
| // unsigned int(32) vertOffN; |
| // unsigned int(32) vertOffD; |
| vert_off: stream.read_ufraction()?, |
| }; |
| Ok(ItemProperty::CleanAperture(clap)) |
| } |
| |
| fn parse_irot(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.10.2 of ISO/IEC 23008-12. |
| let mut bits = stream.sub_bit_stream(1)?; |
| // unsigned int (6) reserved = 0; |
| if bits.read(6)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "invalid reserved bits in irot".into(), |
| )); |
| } |
| // unsigned int (2) angle; |
| let angle = bits.read(2)? as u8; |
| Ok(ItemProperty::ImageRotation(angle)) |
| } |
| |
| fn parse_imir(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.12.1 of ISO/IEC 23008-12. |
| let mut bits = stream.sub_bit_stream(1)?; |
| // unsigned int(7) reserved = 0; |
| if bits.read(7)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "invalid reserved bits in imir".into(), |
| )); |
| } |
| // unsigned int(1) axis; |
| let axis = bits.read(1)? as u8; |
| Ok(ItemProperty::ImageMirror(axis)) |
| } |
| |
| fn parse_a1op(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#operating-point-selector-property-syntax |
| |
| // unsigned int(8) op_index; |
| let op_index = stream.read_u8()?; |
| if op_index > 31 { |
| // 31 is AV1's maximum operating point value (operating_points_cnt_minus_1). |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid op_index ({op_index}) in a1op" |
| ))); |
| } |
| Ok(ItemProperty::OperatingPointSelector(op_index)) |
| } |
| |
| fn parse_lsel(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 6.5.11.1 of ISO/IEC 23008-12. |
| |
| // unsigned int(16) layer_id; |
| let layer_id = stream.read_u16()?; |
| |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#layer-selector-property: |
| // The layer_id indicates the value of the spatial_id to render. The value shall be between 0 |
| // and 3, or the special value 0xFFFF. |
| if layer_id != 0xFFFF && layer_id >= 4 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid layer_id ({layer_id}) in lsel" |
| ))); |
| } |
| Ok(ItemProperty::LayerSelector(layer_id)) |
| } |
| |
| fn parse_a1lx(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#layered-image-indexing-property-syntax |
| let mut bits = stream.sub_bit_stream(1)?; |
| // unsigned int(7) reserved = 0; |
| if bits.read(7)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in a1lx".into(), |
| )); |
| } |
| // unsigned int(1) large_size; |
| let large_size = bits.read_bool()?; |
| let mut layer_sizes: [usize; 3] = [0; 3]; |
| for layer_size in &mut layer_sizes { |
| if large_size { |
| *layer_size = usize_from_u32(stream.read_u32()?)?; |
| } else { |
| *layer_size = usize_from_u16(stream.read_u16()?)?; |
| } |
| } |
| Ok(ItemProperty::AV1LayeredImageIndexing(layer_sizes)) |
| } |
| |
| fn parse_clli(stream: &mut IStream) -> AvifResult<ItemProperty> { |
| // Section 12.1.6.2 of ISO/IEC 14496-12. |
| let clli = ContentLightLevelInformation { |
| // unsigned int(16) max_content_light_level |
| max_cll: stream.read_u16()?, |
| // unsigned int(16) max_pic_average_light_level |
| max_pall: stream.read_u16()?, |
| }; |
| Ok(ItemProperty::ContentLightLevelInformation(clli)) |
| } |
| |
| fn parse_ipco(stream: &mut IStream, is_track: bool) -> AvifResult<Vec<ItemProperty>> { |
| // Section 8.11.14.2 of ISO/IEC 14496-12. |
| let mut properties: Vec<ItemProperty> = Vec::new(); |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "ispe" => properties.push(parse_ispe(&mut sub_stream)?), |
| "pixi" => properties.push(parse_pixi(&mut sub_stream)?), |
| "av1C" => properties.push(parse_av1C(&mut sub_stream)?), |
| "colr" => properties.push(parse_colr(&mut sub_stream)?), |
| "pasp" => properties.push(parse_pasp(&mut sub_stream)?), |
| "auxC" if !is_track => properties.push(parse_auxC(&mut sub_stream)?), |
| "auxi" if is_track => properties.push(parse_auxC(&mut sub_stream)?), |
| "clap" => properties.push(parse_clap(&mut sub_stream)?), |
| "irot" => properties.push(parse_irot(&mut sub_stream)?), |
| "imir" => properties.push(parse_imir(&mut sub_stream)?), |
| "a1op" => properties.push(parse_a1op(&mut sub_stream)?), |
| "lsel" => properties.push(parse_lsel(&mut sub_stream)?), |
| "a1lx" => properties.push(parse_a1lx(&mut sub_stream)?), |
| "clli" => properties.push(parse_clli(&mut sub_stream)?), |
| #[cfg(feature = "heic")] |
| "hvcC" => properties.push(parse_hvcC(&mut sub_stream)?), |
| _ => properties.push(ItemProperty::Unknown(header.box_type)), |
| } |
| } |
| Ok(properties) |
| } |
| |
| fn parse_ipma(stream: &mut IStream) -> AvifResult<Vec<ItemPropertyAssociation>> { |
| // Section 8.11.14.2 of ISO/IEC 14496-12. |
| let (version, flags) = stream.read_version_and_flags()?; |
| // unsigned int(32) entry_count; |
| let entry_count = stream.read_u32()?; |
| let mut ipma: Vec<ItemPropertyAssociation> = create_vec_exact(usize_from_u32(entry_count)?)?; |
| for _i in 0..entry_count { |
| let mut entry = ItemPropertyAssociation::default(); |
| // ISO/IEC 23008-12, First edition, 2017-12, Section 9.3.1: |
| // Each ItemPropertyAssociation box shall be ordered by increasing item_ID, and there |
| // shall be at most one association box for each item_ID, in any |
| // ItemPropertyAssociation box. |
| if version < 1 { |
| // unsigned int(16) item_ID; |
| entry.item_id = stream.read_u16()? as u32; |
| } else { |
| // unsigned int(32) item_ID; |
| entry.item_id = stream.read_u32()?; |
| } |
| if entry.item_id == 0 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "invalid item id ({}) in ipma", |
| entry.item_id |
| ))); |
| } |
| if !ipma.is_empty() { |
| let previous_item_id = ipma.last().unwrap().item_id; |
| if entry.item_id <= previous_item_id { |
| return Err(AvifError::BmffParseFailed( |
| "ipma item ids are not ordered by increasing id".into(), |
| )); |
| } |
| } |
| // unsigned int(8) association_count; |
| let association_count = stream.read_u8()?; |
| for _j in 0..association_count { |
| let mut bits = stream.sub_bit_stream(if flags & 0x1 == 1 { 2 } else { 1 })?; |
| // bit(1) essential; |
| let essential = bits.read_bool()?; |
| if flags & 0x1 == 1 { |
| // unsigned int(15) property_index; |
| entry.associations.push((bits.read(15)? as u16, essential)); |
| } else { |
| //unsigned int(7) property_index; |
| entry.associations.push((bits.read(7)? as u16, essential)); |
| } |
| } |
| ipma.push(entry); |
| } |
| Ok(ipma) |
| } |
| |
| fn parse_iprp(stream: &mut IStream) -> AvifResult<ItemPropertyBox> { |
| // Section 8.11.14.2 of ISO/IEC 14496-12. |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| if header.box_type != "ipco" { |
| return Err(AvifError::BmffParseFailed( |
| "First box in iprp is not ipco".into(), |
| )); |
| } |
| let mut iprp = ItemPropertyBox::default(); |
| // Parse ipco box. |
| { |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| iprp.properties = parse_ipco(&mut sub_stream, /*is_track=*/ false)?; |
| } |
| // Parse ipma boxes. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| if header.box_type != "ipma" { |
| return Err(AvifError::BmffParseFailed( |
| "Found non ipma box in iprp".into(), |
| )); |
| } |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| iprp.associations.append(&mut parse_ipma(&mut sub_stream)?); |
| } |
| Ok(iprp) |
| } |
| |
| fn parse_infe(stream: &mut IStream) -> AvifResult<ItemInfo> { |
| // Section 8.11.6.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version != 2 && version != 3 { |
| return Err(AvifError::BmffParseFailed( |
| "infe box version 2 or 3 expected.".into(), |
| )); |
| } |
| |
| // TODO: check flags. ISO/IEC 23008-12:2017, Section 9.2 says: |
| // The flags field of ItemInfoEntry with version greater than or equal to 2 is specified |
| // as follows: |
| // (flags & 1) equal to 1 indicates that the item is not intended to be a part of the |
| // presentation. For example, when (flags & 1) is equal to 1 for an image item, the |
| // image item should not be displayed. (flags & 1) equal to 0 indicates that the item |
| // is intended to be a part of the presentation. |
| // |
| // See also Section 6.4.2. |
| let mut entry = ItemInfo::default(); |
| if version == 2 { |
| // unsigned int(16) item_ID; |
| entry.item_id = stream.read_u16()? as u32; |
| } else { |
| // unsigned int(32) item_ID; |
| entry.item_id = stream.read_u32()?; |
| } |
| if entry.item_id == 0 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Invalid item id ({}) found in infe", |
| entry.item_id |
| ))); |
| } |
| // unsigned int(16) item_protection_index; |
| entry.item_protection_index = stream.read_u16()?; |
| // unsigned int(32) item_type; |
| entry.item_type = stream.read_string(4)?; |
| |
| // utf8string item_name; |
| entry.item_name = stream.read_c_string()?; |
| |
| if entry.item_type == "mime" { |
| // utf8string content_type; |
| entry.content_type = stream.read_c_string()?; |
| // utf8string content_encoding; //optional |
| } |
| // if (item_type == 'uri ') { |
| // utf8string item_uri_type; |
| // } |
| Ok(entry) |
| } |
| |
| fn parse_iinf(stream: &mut IStream) -> AvifResult<Vec<ItemInfo>> { |
| // Section 8.11.6.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version > 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "Unsupported version {} in iinf box", |
| version |
| ))); |
| } |
| let entry_count: u32 = if version == 0 { |
| // unsigned int(16) entry_count; |
| stream.read_u16()? as u32 |
| } else { |
| // unsigned int(32) entry_count; |
| stream.read_u32()? |
| }; |
| let mut iinf: Vec<ItemInfo> = create_vec_exact(usize_from_u32(entry_count)?)?; |
| for _i in 0..entry_count { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| if header.box_type != "infe" { |
| return Err(AvifError::BmffParseFailed( |
| "Found non infe box in iinf".into(), |
| )); |
| } |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| iinf.push(parse_infe(&mut sub_stream)?); |
| } |
| Ok(iinf) |
| } |
| |
| fn parse_iref(stream: &mut IStream) -> AvifResult<Vec<ItemReference>> { |
| // Section 8.11.12.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| let mut iref: Vec<ItemReference> = Vec::new(); |
| // versions > 1 are not supported. ignore them. |
| if version > 1 { |
| return Ok(iref); |
| } |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let from_item_id: u32 = if version == 0 { |
| // unsigned int(16) from_item_ID; |
| stream.read_u16()? as u32 |
| } else { |
| // unsigned int(32) from_item_ID; |
| stream.read_u32()? |
| }; |
| if from_item_id == 0 { |
| return Err(AvifError::BmffParseFailed( |
| "invalid from_item_id (0) in iref".into(), |
| )); |
| } |
| // unsigned int(16) reference_count; |
| let reference_count = stream.read_u16()?; |
| for index in 0..reference_count { |
| let to_item_id: u32 = if version == 0 { |
| // unsigned int(16) to_item_ID; |
| stream.read_u16()? as u32 |
| } else { |
| // unsigned int(32) to_item_ID; |
| stream.read_u32()? |
| }; |
| if to_item_id == 0 { |
| return Err(AvifError::BmffParseFailed( |
| "invalid to_item_id (0) in iref".into(), |
| )); |
| } |
| iref.push(ItemReference { |
| from_item_id, |
| to_item_id, |
| reference_type: header.box_type.clone(), |
| index: index as u32, |
| }); |
| } |
| } |
| Ok(iref) |
| } |
| |
| fn parse_idat(stream: &mut IStream) -> AvifResult<Vec<u8>> { |
| // Section 8.11.11.2 of ISO/IEC 14496-12. |
| if !stream.has_bytes_left()? { |
| return Err(AvifError::BmffParseFailed("Invalid idat size (0)".into())); |
| } |
| let mut idat: Vec<u8> = Vec::with_capacity(stream.bytes_left()?); |
| idat.extend_from_slice(stream.get_slice(stream.bytes_left()?)?); |
| Ok(idat) |
| } |
| |
| fn parse_meta(stream: &mut IStream) -> AvifResult<MetaBox> { |
| // Section 8.11.1.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| let mut meta = MetaBox::default(); |
| |
| // Parse the first hdlr box. |
| { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| if header.box_type != "hdlr" { |
| return Err(AvifError::BmffParseFailed( |
| "first box in meta is not hdlr".into(), |
| )); |
| } |
| let handler_type = parse_hdlr(&mut stream.sub_stream(&header.size)?)?; |
| if handler_type != "pict" { |
| // Section 6.2 of ISO/IEC 23008-12: |
| // The handler type for the MetaBox shall be 'pict'. |
| // https://aomediacodec.github.io/av1-avif/v1.1.0.html#image-sequences does not apply |
| // because this function is only called for the MetaBox but it would work too: |
| // The track handler for an AV1 Image Sequence shall be pict. |
| return Err(AvifError::BmffParseFailed( |
| "Box[hdlr] handler_type is not 'pict'".into(), |
| )); |
| } |
| } |
| |
| let mut boxes_seen: HashSet<String> = HashSet::with_hasher(NonRandomHasherState); |
| boxes_seen.insert(String::from("hdlr")); |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| match header.box_type.as_str() { |
| "hdlr" | "iloc" | "pitm" | "iprp" | "iinf" | "iref" | "idat" => { |
| if boxes_seen.contains(&header.box_type) { |
| return Err(AvifError::BmffParseFailed(format!( |
| "duplicate {} box in meta.", |
| header.box_type |
| ))); |
| } |
| boxes_seen.insert(header.box_type.clone()); |
| } |
| _ => {} |
| } |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "iloc" => meta.iloc = parse_iloc(&mut sub_stream)?, |
| "pitm" => meta.primary_item_id = parse_pitm(&mut sub_stream)?, |
| "iprp" => meta.iprp = parse_iprp(&mut sub_stream)?, |
| "iinf" => meta.iinf = parse_iinf(&mut sub_stream)?, |
| "iref" => meta.iref = parse_iref(&mut sub_stream)?, |
| "idat" => meta.idat = parse_idat(&mut sub_stream)?, |
| _ => {} |
| } |
| } |
| Ok(meta) |
| } |
| |
| fn parse_tkhd(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.3.2.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version == 1 { |
| // unsigned int(64) creation_time; |
| stream.skip_u64()?; |
| // unsigned int(64) modification_time; |
| stream.skip_u64()?; |
| // unsigned int(32) track_ID; |
| track.id = stream.read_u32()?; |
| // const unsigned int(32) reserved = 0; |
| if stream.read_u32()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in tkhd".into(), |
| )); |
| } |
| // unsigned int(64) duration; |
| track.track_duration = stream.read_u64()?; |
| } else if version == 0 { |
| // unsigned int(32) creation_time; |
| stream.skip_u32()?; |
| // unsigned int(32) modification_time; |
| stream.skip_u32()?; |
| // unsigned int(32) track_ID; |
| track.id = stream.read_u32()?; |
| // const unsigned int(32) reserved = 0; |
| if stream.read_u32()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in tkhd".into(), |
| )); |
| } |
| // unsigned int(32) duration; |
| track.track_duration = stream.read_u32()? as u64; |
| } else { |
| return Err(AvifError::BmffParseFailed(format!( |
| "unsupported version ({version}) in trak" |
| ))); |
| } |
| |
| // const unsigned int(32)[2] reserved = 0; |
| if stream.read_u32()? != 0 || stream.read_u32()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in tkhd".into(), |
| )); |
| } |
| // The following fields should be 0 but are ignored instead. |
| // template int(16) layer = 0; |
| stream.skip(2)?; |
| // template int(16) alternate_group = 0; |
| stream.skip(2)?; |
| // template int(16) volume = {if track_is_audio 0x0100 else 0}; |
| stream.skip(2)?; |
| // const unsigned int(16) reserved = 0; |
| if stream.read_u16()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in tkhd".into(), |
| )); |
| } |
| // template int(32)[9] matrix= { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }; // unity matrix |
| stream.skip(4 * 9)?; |
| |
| // unsigned int(32) width; |
| track.width = stream.read_u32()? >> 16; |
| // unsigned int(32) height; |
| track.height = stream.read_u32()? >> 16; |
| |
| Ok(()) |
| } |
| |
| fn parse_mdhd(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.4.2.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version == 1 { |
| // unsigned int(64) creation_time; |
| stream.skip_u64()?; |
| // unsigned int(64) modification_time; |
| stream.skip_u64()?; |
| // unsigned int(32) timescale; |
| track.media_timescale = stream.read_u32()?; |
| // unsigned int(64) duration; |
| track.media_duration = stream.read_u64()?; |
| } else if version == 0 { |
| // unsigned int(32) creation_time; |
| stream.skip_u32()?; |
| // unsigned int(32) modification_time; |
| stream.skip_u32()?; |
| // unsigned int(32) timescale; |
| track.media_timescale = stream.read_u32()?; |
| // unsigned int(32) duration; |
| track.media_duration = stream.read_u32()? as u64; |
| } else { |
| return Err(AvifError::BmffParseFailed(format!( |
| "unsupported version ({version}) in mdhd" |
| ))); |
| } |
| |
| let mut bits = stream.sub_bit_stream(4)?; |
| // bit(1) pad = 0; |
| if bits.read(1)? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in mdhd".into(), |
| )); |
| } |
| // unsigned int(5)[3] language; // ISO-639-2/T language code |
| bits.skip(5 * 3)?; |
| // unsigned int(16) pre_defined = 0; ("Readers should expect any value") |
| bits.skip(2)?; |
| Ok(()) |
| } |
| |
| fn parse_stco( |
| stream: &mut IStream, |
| sample_table: &mut SampleTable, |
| large_offset: bool, |
| ) -> AvifResult<()> { |
| // Section 8.7.5.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) entry_count; |
| let entry_count = usize_from_u32(stream.read_u32()?)?; |
| sample_table.chunk_offsets = create_vec_exact(entry_count)?; |
| for _ in 0..entry_count { |
| let chunk_offset: u64 = if large_offset { |
| // unsigned int(64) chunk_offset; |
| stream.read_u64()? |
| } else { |
| // unsigned int(32) chunk_offset; |
| stream.read_u32()? as u64 |
| }; |
| sample_table.chunk_offsets.push(chunk_offset); |
| } |
| Ok(()) |
| } |
| |
| fn parse_stsc(stream: &mut IStream, sample_table: &mut SampleTable) -> AvifResult<()> { |
| // Section 8.7.4.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) entry_count; |
| let entry_count = usize_from_u32(stream.read_u32()?)?; |
| sample_table.sample_to_chunk = create_vec_exact(entry_count)?; |
| for i in 0..entry_count { |
| let stsc = SampleToChunk { |
| // unsigned int(32) first_chunk; |
| first_chunk: stream.read_u32()?, |
| // unsigned int(32) samples_per_chunk; |
| samples_per_chunk: stream.read_u32()?, |
| // unsigned int(32) sample_description_index; |
| sample_description_index: stream.read_u32()?, |
| }; |
| if i == 0 { |
| if stsc.first_chunk != 1 { |
| return Err(AvifError::BmffParseFailed( |
| "stsc does not begin with chunk 1.".into(), |
| )); |
| } |
| } else if stsc.first_chunk <= sample_table.sample_to_chunk.last().unwrap().first_chunk { |
| return Err(AvifError::BmffParseFailed( |
| "stsc chunks are not strictly increasing.".into(), |
| )); |
| } |
| if stsc.sample_description_index == 0 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "sample_description_index is {} in stsc chunk.", |
| stsc.sample_description_index |
| ))); |
| } |
| sample_table.sample_to_chunk.push(stsc); |
| } |
| Ok(()) |
| } |
| |
| fn parse_stsz(stream: &mut IStream, sample_table: &mut SampleTable) -> AvifResult<()> { |
| // Section 8.7.3.2.1 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) sample_size; |
| let sample_size = stream.read_u32()?; |
| // unsigned int(32) sample_count; |
| let sample_count = usize_from_u32(stream.read_u32()?)?; |
| |
| if sample_size > 0 { |
| sample_table.sample_size = SampleSize::FixedSize(sample_size); |
| return Ok(()); |
| } |
| let mut sample_sizes: Vec<u32> = create_vec_exact(sample_count)?; |
| for _ in 0..sample_count { |
| // unsigned int(32) entry_size; |
| sample_sizes.push(stream.read_u32()?); |
| } |
| sample_table.sample_size = SampleSize::Sizes(sample_sizes); |
| Ok(()) |
| } |
| |
| fn parse_stss(stream: &mut IStream, sample_table: &mut SampleTable) -> AvifResult<()> { |
| // Section 8.6.2.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) entry_count; |
| let entry_count = usize_from_u32(stream.read_u32()?)?; |
| sample_table.sync_samples = create_vec_exact(entry_count)?; |
| for _ in 0..entry_count { |
| // unsigned int(32) sample_number; |
| sample_table.sync_samples.push(stream.read_u32()?); |
| } |
| Ok(()) |
| } |
| |
| fn parse_stts(stream: &mut IStream, sample_table: &mut SampleTable) -> AvifResult<()> { |
| // Section 8.6.1.2.2 of ISO/IEC 14496-12. |
| let (_version, _flags) = stream.read_and_enforce_version_and_flags(0)?; |
| // unsigned int(32) entry_count; |
| let entry_count = usize_from_u32(stream.read_u32()?)?; |
| sample_table.time_to_sample = create_vec_exact(entry_count)?; |
| for _ in 0..entry_count { |
| let stts = TimeToSample { |
| // unsigned int(32) sample_count; |
| sample_count: stream.read_u32()?, |
| // unsigned int(32) sample_delta; |
| sample_delta: stream.read_u32()?, |
| }; |
| sample_table.time_to_sample.push(stts); |
| } |
| Ok(()) |
| } |
| |
| fn parse_sample_entry(stream: &mut IStream, format: String) -> AvifResult<SampleDescription> { |
| // Section 8.5.2.2 of ISO/IEC 14496-12. |
| let mut sample_entry = SampleDescription { |
| format, |
| ..SampleDescription::default() |
| }; |
| // const unsigned int(8) reserved[6] = 0; |
| if stream.read_u8()? != 0 |
| || stream.read_u8()? != 0 |
| || stream.read_u8()? != 0 |
| || stream.read_u8()? != 0 |
| || stream.read_u8()? != 0 |
| || stream.read_u8()? != 0 |
| { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in SampleEntry of stsd".into(), |
| )); |
| } |
| // unsigned int(16) data_reference_index; |
| stream.skip(2)?; |
| |
| if sample_entry.is_supported_format() { |
| // https://aomediacodec.github.io/av1-isobmff/v1.2.0.html#av1sampleentry-syntax: |
| // class AV1SampleEntry extends VisualSampleEntry('av01'){ |
| // AV1CodecConfigurationBox config; |
| // } |
| // https://aomediacodec.github.io/av1-isobmff/v1.2.0.html#av1codecconfigurationbox-syntax: |
| // class AV1CodecConfigurationBox extends Box('av1C'){ |
| // AV1CodecConfigurationRecord av1Config; |
| // } |
| |
| // Section 12.1.3.2 of ISO/IEC 14496-12: |
| // class VisualSampleEntry(codingname) extends SampleEntry(codingname) |
| |
| // unsigned int(16) pre_defined = 0; ("Readers should expect any value") |
| stream.skip(2)?; |
| // const unsigned int(16) reserved = 0; |
| if stream.read_u16()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in VisualSampleEntry of stsd".into(), |
| )); |
| } |
| // unsigned int(32) pre_defined[3] = 0; |
| stream.skip(4 * 3)?; |
| // unsigned int(16) width; |
| stream.skip(2)?; |
| // unsigned int(16) height; |
| stream.skip(2)?; |
| // template unsigned int(32) horizresolution = 0x00480000; // 72 dpi |
| stream.skip_u32()?; |
| // template unsigned int(32) vertresolution = 0x00480000; // 72 dpi |
| stream.skip_u32()?; |
| // const unsigned int(32) reserved = 0; |
| if stream.read_u32()? != 0 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid reserved bits in VisualSampleEntry of stsd".into(), |
| )); |
| } |
| // template unsigned int(16) frame_count; |
| stream.skip(2)?; |
| // uint(8) compressorname[32]; |
| stream.skip(32)?; |
| // template unsigned int(16) depth = 0x0018; |
| if stream.read_u16()? != 0x0018 { |
| return Err(AvifError::BmffParseFailed( |
| "Invalid depth in VisualSampleEntry of stsd".into(), |
| )); |
| } |
| // unsigned int(16) pre_defined = 0; ("Readers should expect any value") |
| stream.skip(2)?; |
| |
| // other boxes from derived specifications |
| // CleanApertureBox clap; // optional |
| // PixelAspectRatioBox pasp; // optional |
| |
| // Now read any of 'av1C', 'clap', 'pasp' etc. |
| sample_entry.properties = parse_ipco( |
| &mut stream.sub_stream(&BoxSize::UntilEndOfStream)?, |
| /*is_track=*/ true, |
| )?; |
| |
| if !sample_entry |
| .properties |
| .iter() |
| .any(|p| matches!(p, ItemProperty::CodecConfiguration(_))) |
| { |
| return Err(AvifError::BmffParseFailed( |
| "AV1SampleEntry must contain an AV1CodecConfigurationRecord".into(), |
| )); |
| } |
| } |
| Ok(sample_entry) |
| } |
| |
| fn parse_stsd(stream: &mut IStream, sample_table: &mut SampleTable) -> AvifResult<()> { |
| // Section 8.5.2.2 of ISO/IEC 14496-12. |
| let (version, _flags) = stream.read_version_and_flags()?; |
| if version != 0 && version != 1 { |
| // Section 8.5.2.3 of ISO/IEC 14496-12: |
| // version is set to zero. A version number of 1 shall be treated as a version of 0. |
| return Err(AvifError::BmffParseFailed( |
| "stsd box version 0 or 1 expected.".into(), |
| )); |
| } |
| // unsigned int(32) entry_count; |
| let entry_count = usize_from_u32(stream.read_u32()?)?; |
| sample_table.sample_descriptions = create_vec_exact(entry_count)?; |
| for _ in 0..entry_count { |
| // aligned(8) abstract class SampleEntry (unsigned int(32) format) extends Box(format) |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let sample_entry = |
| parse_sample_entry(&mut stream.sub_stream(&header.size)?, header.box_type)?; |
| sample_table.sample_descriptions.push(sample_entry); |
| } |
| Ok(()) |
| } |
| |
| fn parse_stbl(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.5.1.2 of ISO/IEC 14496-12. |
| if track.sample_table.is_some() { |
| return Err(AvifError::BmffParseFailed( |
| "duplicate stbl for track.".into(), |
| )); |
| } |
| let mut sample_table = SampleTable::default(); |
| let mut boxes_seen: HashSet<String> = HashSet::with_hasher(NonRandomHasherState); |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| if boxes_seen.contains(&header.box_type) { |
| return Err(AvifError::BmffParseFailed(format!( |
| "duplicate box in stbl: {}", |
| header.box_type |
| ))); |
| } |
| let mut skipped_box = false; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "stco" => { |
| if boxes_seen.contains("co64") { |
| return Err(AvifError::BmffParseFailed( |
| "exactly one of co64 or stco is allowed in stbl".into(), |
| )); |
| } |
| parse_stco(&mut sub_stream, &mut sample_table, false)?; |
| } |
| "co64" => { |
| if boxes_seen.contains("stco") { |
| return Err(AvifError::BmffParseFailed( |
| "exactly one of co64 or stco is allowed in stbl".into(), |
| )); |
| } |
| parse_stco(&mut sub_stream, &mut sample_table, true)?; |
| } |
| "stsc" => parse_stsc(&mut sub_stream, &mut sample_table)?, |
| "stsz" => parse_stsz(&mut sub_stream, &mut sample_table)?, |
| "stss" => parse_stss(&mut sub_stream, &mut sample_table)?, |
| "stts" => parse_stts(&mut sub_stream, &mut sample_table)?, |
| "stsd" => parse_stsd(&mut sub_stream, &mut sample_table)?, |
| _ => skipped_box = true, |
| } |
| // For boxes that are skipped, we do not need to validate if they occur exactly once or |
| // not. |
| if !skipped_box { |
| boxes_seen.insert(header.box_type.clone()); |
| } |
| } |
| track.sample_table = Some(sample_table); |
| Ok(()) |
| } |
| |
| fn parse_minf(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.4.4.2 of ISO/IEC 14496-12. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| if header.box_type == "stbl" { |
| parse_stbl(&mut sub_stream, track)?; |
| } |
| } |
| Ok(()) |
| } |
| |
| fn parse_mdia(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.4.1.2 of ISO/IEC 14496-12. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "mdhd" => parse_mdhd(&mut sub_stream, track)?, |
| "minf" => parse_minf(&mut sub_stream, track)?, |
| "hdlr" => track.handler_type = parse_hdlr(&mut sub_stream)?, |
| _ => {} |
| } |
| } |
| Ok(()) |
| } |
| |
| fn parse_tref(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| // Section 8.3.3.2 of ISO/IEC 14496-12. |
| |
| // TrackReferenceTypeBox []; |
| while stream.has_bytes_left()? { |
| // aligned(8) class TrackReferenceTypeBox (reference_type) extends Box(reference_type) |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "auxl" => { |
| // unsigned int(32) track_IDs[]; |
| // Use only the first one and skip the rest. |
| track.aux_for_id = Some(sub_stream.read_u32()?); |
| } |
| "prem" => { |
| // unsigned int(32) track_IDs[]; |
| // Use only the first one and skip the rest. |
| track.prem_by_id = Some(sub_stream.read_u32()?); |
| } |
| _ => {} |
| } |
| } |
| Ok(()) |
| } |
| |
| fn parse_elst(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| if track.elst_seen { |
| return Err(AvifError::BmffParseFailed( |
| "more than one elst box was found for track".into(), |
| )); |
| } |
| track.elst_seen = true; |
| |
| // Section 8.6.6.2 of ISO/IEC 14496-12. |
| let (version, flags) = stream.read_version_and_flags()?; |
| |
| // Section 8.6.6.3 of ISO/IEC 14496-12: |
| // flags - the following values are defined. The values of flags greater than 1 are reserved |
| // RepeatEdits 1 |
| if (flags & 1) == 0 { |
| // The only EditList feature that we support is repetition count for animated images. So in |
| // this case, we know that the repetition count is zero and we do not care about the rest |
| // of this box. |
| track.is_repeating = false; |
| return Ok(()); |
| } |
| track.is_repeating = true; |
| |
| // unsigned int(32) entry_count; |
| let entry_count = stream.read_u32()?; |
| if entry_count != 1 { |
| return Err(AvifError::BmffParseFailed(format!( |
| "elst has entry_count ({entry_count}) != 1" |
| ))); |
| } |
| |
| if version == 1 { |
| // unsigned int(64) segment_duration; |
| track.segment_duration = stream.read_u64()?; |
| // int(64) media_time; |
| stream.skip(8)?; |
| } else if version == 0 { |
| // unsigned int(32) segment_duration; |
| track.segment_duration = stream.read_u32()? as u64; |
| // int(32) media_time; |
| stream.skip(4)?; |
| } else { |
| return Err(AvifError::BmffParseFailed( |
| "unsupported version in elst".into(), |
| )); |
| } |
| // int(16) media_rate_integer; |
| stream.skip(2)?; |
| // int(16) media_rate_fraction; |
| stream.skip(2)?; |
| |
| if track.segment_duration == 0 { |
| return Err(AvifError::BmffParseFailed( |
| "invalid value for segment_duration (0)".into(), |
| )); |
| } |
| Ok(()) |
| } |
| |
| fn parse_edts(stream: &mut IStream, track: &mut Track) -> AvifResult<()> { |
| if track.elst_seen { |
| // This function always exits with track.elst_seen set to true. So it is sufficient to |
| // check track.elst_seen to verify the uniqueness of the edts box. |
| return Err(AvifError::BmffParseFailed( |
| "multiple edts boxes found for track.".into(), |
| )); |
| } |
| |
| // Section 8.6.5.2 of ISO/IEC 14496-12. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| if header.box_type == "elst" { |
| parse_elst(&mut sub_stream, track)?; |
| } |
| } |
| |
| if !track.elst_seen { |
| return Err(AvifError::BmffParseFailed( |
| "elst box was not found in edts".into(), |
| )); |
| } |
| Ok(()) |
| } |
| |
| fn parse_trak(stream: &mut IStream) -> AvifResult<Track> { |
| let mut track = Track::default(); |
| let mut tkhd_seen = false; |
| // Section 8.3.1.2 of ISO/IEC 14496-12. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| match header.box_type.as_str() { |
| "tkhd" => { |
| if tkhd_seen { |
| return Err(AvifError::BmffParseFailed( |
| "trak box contains multiple tkhd boxes".into(), |
| )); |
| } |
| parse_tkhd(&mut sub_stream, &mut track)?; |
| tkhd_seen = true; |
| } |
| "mdia" => parse_mdia(&mut sub_stream, &mut track)?, |
| "tref" => parse_tref(&mut sub_stream, &mut track)?, |
| "edts" => parse_edts(&mut sub_stream, &mut track)?, |
| "meta" => track.meta = Some(parse_meta(&mut sub_stream)?), |
| _ => {} |
| } |
| } |
| if !tkhd_seen { |
| return Err(AvifError::BmffParseFailed( |
| "trak box did not contain a tkhd box".into(), |
| )); |
| } |
| Ok(track) |
| } |
| |
| fn parse_moov(stream: &mut IStream) -> AvifResult<Vec<Track>> { |
| let mut tracks: Vec<Track> = Vec::new(); |
| // Section 8.2.1.2 of ISO/IEC 14496-12. |
| while stream.has_bytes_left()? { |
| let header = parse_header(stream, /*top_level=*/ false)?; |
| let mut sub_stream = stream.sub_stream(&header.size)?; |
| if header.box_type == "trak" { |
| let track = parse_trak(&mut sub_stream)?; |
| if track.is_video_handler() && (track.width == 0 || track.height == 0) { |
| return Err(AvifError::BmffParseFailed( |
| "invalid track dimensions".into(), |
| )); |
| } |
| tracks.push(track); |
| } |
| } |
| if tracks.is_empty() { |
| return Err(AvifError::BmffParseFailed( |
| "moov box does not contain any tracks".into(), |
| )); |
| } |
| Ok(tracks) |
| } |
| |
| pub(crate) fn parse(io: &mut GenericIO) -> AvifResult<AvifBoxes> { |
| let mut ftyp: Option<FileTypeBox> = None; |
| let mut meta: Option<MetaBox> = None; |
| let mut tracks: Option<Vec<Track>> = None; |
| let mut parse_offset: u64 = 0; |
| loop { |
| // Read just enough to get the longest possible valid box header (4+4+8+16 bytes). |
| let header_data = io.read(parse_offset, 32)?; |
| if header_data.is_empty() { |
| // No error and size is 0. We have reached the end of the stream. |
| break; |
| } |
| let mut header_stream = IStream::create(header_data); |
| let header = parse_header(&mut header_stream, /*top_level=*/ true)?; |
| parse_offset = parse_offset |
| .checked_add(header_stream.offset as u64) |
| .ok_or(AvifError::BmffParseFailed("invalid parse offset".into()))?; |
| |
| // Read the rest of the box if necessary. |
| match header.box_type.as_str() { |
| "ftyp" | "meta" | "moov" => { |
| if ftyp.is_none() && header.box_type != "ftyp" { |
| // Section 6.3.4 of ISO/IEC 14496-12: |
| // The FileTypeBox shall occur before any variable-length box. Only a |
| // fixed-size box such as a file signature, if required, may precede it. |
| return Err(AvifError::BmffParseFailed(format!( |
| "expected ftyp box. found {}.", |
| header.box_type, |
| ))); |
| } |
| let box_data = match header.size { |
| BoxSize::UntilEndOfStream => io.read(parse_offset, usize::MAX)?, |
| BoxSize::FixedSize(size) => io.read_exact(parse_offset, size)?, |
| }; |
| let mut box_stream = IStream::create(box_data); |
| match header.box_type.as_str() { |
| "ftyp" => { |
| ftyp = Some(parse_ftyp(&mut box_stream)?); |
| if !ftyp.unwrap_ref().is_avif() { |
| return Err(AvifError::InvalidFtyp); |
| } |
| } |
| "meta" => meta = Some(parse_meta(&mut box_stream)?), |
| "moov" => tracks = Some(parse_moov(&mut box_stream)?), |
| _ => {} // Not reached. |
| } |
| if ftyp.is_some() { |
| let ftyp = ftyp.unwrap_ref(); |
| if (!ftyp.needs_meta() || meta.is_some()) |
| && (!ftyp.needs_moov() || tracks.is_some()) |
| { |
| // Enough information has been parsed to consider parse a success. |
| break; |
| } |
| } |
| } |
| _ => {} |
| } |
| if header.size == BoxSize::UntilEndOfStream { |
| // There is no other box after this one because it goes till the end of the stream. |
| break; |
| } |
| parse_offset = parse_offset |
| .checked_add(header.size() as u64) |
| .ok_or(AvifError::BmffParseFailed("invalid parse offset".into()))?; |
| } |
| if ftyp.is_none() { |
| return Err(AvifError::InvalidFtyp); |
| } |
| let ftyp = ftyp.unwrap(); |
| if (ftyp.needs_meta() && meta.is_none()) || (ftyp.needs_moov() && tracks.is_none()) { |
| return Err(AvifError::TruncatedData); |
| } |
| Ok(AvifBoxes { |
| ftyp, |
| meta: meta.unwrap_or_default(), |
| tracks: tracks.unwrap_or_default(), |
| }) |
| } |
| |
| pub(crate) fn peek_compatible_file_type(data: &[u8]) -> AvifResult<bool> { |
| let mut stream = IStream::create(data); |
| let header = parse_header(&mut stream, /*top_level=*/ true)?; |
| if header.box_type != "ftyp" { |
| // Section 6.3.4 of ISO/IEC 14496-12: |
| // The FileTypeBox shall occur before any variable-length box. |
| // Only a fixed-size box such as a file signature, if required, may precede it. |
| return Ok(false); |
| } |
| let header_size = match header.size { |
| BoxSize::FixedSize(size) => size, |
| // The 'ftyp' box goes on till the end of the file. Either there is no brand requiring |
| // anything in the file but a FileTypebox (so not AVIF), or it is invalid. |
| BoxSize::UntilEndOfStream => return Ok(false), |
| }; |
| let ftyp = if header_size > stream.bytes_left()? { |
| let mut header_stream = stream.sub_stream(&BoxSize::FixedSize(stream.bytes_left()?))?; |
| parse_truncated_ftyp(&mut header_stream) |
| } else { |
| let mut header_stream = stream.sub_stream(&header.size)?; |
| parse_ftyp(&mut header_stream)? |
| }; |
| Ok(ftyp.is_avif()) |
| } |
| |
| pub(crate) fn parse_tmap(stream: &mut IStream) -> AvifResult<Option<GainMapMetadata>> { |
| // Experimental, not yet specified. |
| |
| // unsigned int(8) version = 0; |
| let version = stream.read_u8()?; |
| if version != 0 { |
| return Ok(None); // Unsupported version. |
| } |
| // unsigned int(16) minimum_version; |
| let minimum_version = stream.read_u16()?; |
| let supported_version = 0; |
| if minimum_version > supported_version { |
| return Ok(None); // Unsupported version. |
| } |
| // unsigned int(16) writer_version; |
| let writer_version = stream.read_u16()?; |
| |
| let mut metadata = GainMapMetadata::default(); |
| let mut bits = stream.sub_bit_stream(1)?; |
| // unsigned int(1) is_multichannel; |
| let is_multichannel = bits.read_bool()?; |
| let channel_count = if is_multichannel { 3 } else { 1 }; |
| // unsigned int(1) use_base_colour_space; |
| metadata.use_base_color_space = bits.read_bool()?; |
| // unsigned int(6) reserved; |
| bits.skip(6)?; |
| |
| // unsigned int(32) base_hdr_headroom_numerator; |
| // unsigned int(32) base_hdr_headroom_denominator; |
| metadata.base_hdr_headroom = stream.read_ufraction()?; |
| // unsigned int(32) alternate_hdr_headroom_numerator; |
| // unsigned int(32) alternate_hdr_headroom_denominator; |
| metadata.alternate_hdr_headroom = stream.read_ufraction()?; |
| for i in 0..channel_count { |
| // int(32) gain_map_min_numerator; |
| // unsigned int(32) gain_map_min_denominator |
| metadata.min[i] = stream.read_fraction()?; |
| // int(32) gain_map_max_numerator; |
| // unsigned int(32) gain_map_max_denominator; |
| metadata.max[i] = stream.read_fraction()?; |
| // unsigned int(32) gamma_numerator; |
| // unsigned int(32) gamma_denominator; |
| metadata.gamma[i] = stream.read_ufraction()?; |
| // int(32) base_offset_numerator; |
| // unsigned int(32) base_offset_denominator; |
| metadata.base_offset[i] = stream.read_fraction()?; |
| // int(32) alternate_offset_numerator; |
| // unsigned int(32) alternate_offset_denominator; |
| metadata.alternate_offset[i] = stream.read_fraction()?; |
| } |
| |
| // Fill the remaining values by copying those from the first channel. |
| for i in channel_count..3 { |
| metadata.min[i] = metadata.min[0]; |
| metadata.max[i] = metadata.max[0]; |
| metadata.gamma[i] = metadata.gamma[0]; |
| metadata.base_offset[i] = metadata.base_offset[0]; |
| metadata.alternate_offset[i] = metadata.alternate_offset[0]; |
| } |
| if writer_version <= supported_version && stream.has_bytes_left()? { |
| return Err(AvifError::InvalidToneMappedImage( |
| "invalid trailing bytes in tmap box".into(), |
| )); |
| } |
| metadata.is_valid()?; |
| Ok(Some(metadata)) |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use crate::parser::mp4box; |
| use crate::AvifResult; |
| |
| #[test] |
| fn peek_compatible_file_type() -> AvifResult<()> { |
| let buf = [ |
| 0x00, 0x00, 0x00, 0x20, 0x66, 0x74, 0x79, 0x70, // |
| 0x61, 0x76, 0x69, 0x66, 0x00, 0x00, 0x00, 0x00, // |
| 0x61, 0x76, 0x69, 0x66, 0x6d, 0x69, 0x66, 0x31, // |
| 0x6d, 0x69, 0x61, 0x66, 0x4d, 0x41, 0x31, 0x41, // |
| 0x00, 0x00, 0x00, 0xf2, 0x6d, 0x65, 0x74, 0x61, // |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, // |
| ]; |
| // Peeking should succeed starting from byte length 12. Since that is the end offset of the |
| // first valid AVIF brand. |
| let min_required_bytes = 12; |
| for i in 0..buf.len() { |
| let res = mp4box::peek_compatible_file_type(&buf[..i]); |
| if i < min_required_bytes { |
| // Not enough bytes. The return should either be an error or false. |
| assert!(res.is_err() || !res.unwrap()); |
| } else { |
| assert!(res?); |
| } |
| } |
| Ok(()) |
| } |
| } |
