Read and expose Exif and XMP metadata in the AvifContext

Author: amyspark

mp4parse/src/lib.rs

@@ -1594,6 +1594,10 @@ pub struct AvifContext {
     pub sequence: Option<MediaContext>,
     /// A collection of unsupported features encountered during the parse
     pub unsupported_features: UnsupportedFeatures,
+    /// AVIF box containing the Exif metadata, if any
+    exif_metadata: Option<AvifItem>,
+    /// AVIF box containing the XMP metadata, if any
+    xmp_metadata: Option<AvifItem>,
 }
 
 impl AvifContext {
@@ -1655,6 +1659,25 @@ impl AvifContext {
         }
     }
 
+    pub fn exif_metadata_is_present(&self) -> bool {
+        self.exif_metadata.is_some()
+    }
+
+    pub fn exif_metadata(&self) -> Option<&[u8]> {
+        self.exif_metadata
+            .as_ref()
+            .map(|item| self.item_as_slice(item))
+    }
+
+    pub fn xmp_metadata_is_present(&self) -> bool {
+        self.xmp_metadata.is_some()
+    }
+
+    pub fn xmp_metadata(&self) -> Option<&[u8]> {
+        self.xmp_metadata
+            .as_ref()
+            .map(|item| self.item_as_slice(item))
+    }
 
     pub fn spatial_extents(&self) -> Result<&ImageSpatialExtentsProperty> {
         if let Some(primary_item) = &self.primary_item {
@@ -1970,7 +1993,7 @@ impl DataBox {
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 struct PropertyIndex(u16);
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd)]
-struct ItemId(u32);
+pub struct ItemId(u32);
 
 impl ItemId {
     fn read(src: &mut impl ReadBytesExt, version: u8) -> Result<ItemId> {
@@ -1986,9 +2009,12 @@ impl ItemId {
 /// 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,
+pub struct ItemInfoEntry {
+    pub item_id: ItemId,
+    pub item_type: u32,
+    pub item_name: TryVec<u8>,
+    pub content_type: Option<TryVec<u8>>,
+    pub content_encoding: Option<TryVec<u8>>
 }
 
 /// See ISOBMFF (ISO 14496-12:2020) § 8.11.12
@@ -2276,6 +2302,26 @@ impl<T> Drop for BMFFBox<'_, T> {
     }
 }
 
+impl<T: ReadBytesExt> BMFFBox<'_, T> {
+    fn read_string(&mut self, strictness: ParseStrictness) -> Result<TryVec<u8>> {
+        let mut s = TryVec::new();
+        loop {
+            let v = self.read_u8()?;
+            s.push(v)?;
+            if v == 0 {
+                break;
+            }
+        }
+        if let Err(_) = std::str::from_utf8(&s) {
+            fail_with_status_if(
+                strictness != ParseStrictness::Permissive,
+                Status::InvalidUtf8,
+            )?;
+        }
+        Ok(s)
+    }
+}
+
 /// Read and parse a box header.
 ///
 /// Call this first to determine the type of a particular mp4 box
@@ -2577,24 +2623,17 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
     debug!("alpha_item_id: {alpha_item_id:?}");
     let mut primary_item = None;
     let mut alpha_item = None;
+    let mut items: std::collections::HashMap<ItemId, AvifItem> = Default::default();
 
     // 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());
+        let mut item: Option<AvifItem> = 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))
+            item = Some(AvifItem::with_inline_data(item_id))
         }
 
         trace!(
@@ -2607,10 +2646,10 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
         // 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 {
+                match &mut item {
                     None => {
                         trace!("Using IsobmffItem::Location");
-                        *item = Some(AvifItem {
+                        item = Some(AvifItem {
                             id: item_id,
                             image_data: dat.location(extent),
                         });
@@ -2670,6 +2709,14 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
         }
 
         assert!(item.is_some());
+
+        if Some(item_id) == primary_item_id {
+            primary_item = item;
+        } else if Some(item_id) == alpha_item_id {
+            alpha_item = item;
+        } else {
+            items.insert(item_id, item.unwrap());
+        };
     }
 
     if (primary_item_id.is_some() && primary_item.is_none())
@@ -2773,6 +2820,21 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
     check_image_item(&mut primary_item)?;
     check_image_item(&mut alpha_item)?;
 
+    let mut exif_metadata = None;
+    let mut xmp_metadata = None;
+
+    item_infos.into_iter().for_each(|item| {
+        if &item.item_type.to_be_bytes() == b"Exif" {
+            exif_metadata = items.remove(&item.item_id);
+        } else if &item.item_type.to_be_bytes() == b"mime"
+            && item
+                .content_type
+                .is_some_and(|v| v.as_slice() == b"application/rdf+xml")
+        {
+            xmp_metadata = items.remove(&item.item_id);
+        }
+    });
+
     Ok(AvifContext {
         strictness,
         media_storage,
@@ -2783,6 +2845,8 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
         item_properties,
         major_brand,
         sequence: image_sequence,
+        exif_metadata,
+        xmp_metadata,
         unsupported_features,
     })
 }
@@ -2988,15 +3052,30 @@ fn read_infe<T: Read>(
     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 }))
+        skip_box_remain(src)?;
+        return Ok(None);
     }
+
+    let item_name = src.read_string(strictness)?;
+
+    let (content_type, content_encoding) = if item_name.as_slice() == b"mime" {
+        (
+            Some(src.read_string(strictness)?),
+            Some(src.read_string(strictness)?),
+        )
+    } else {
+        (None, None)
+    };
+
+    Ok(Some(ItemInfoEntry {
+        item_id,
+        item_type,
+        item_name,
+        content_type,
+        content_encoding
+    }))
 }
 
 /// Parse an Item Reference Box