feat: Add support for more tags from Canon CR3 files

Remove MultiExifIter, since it seems preferable to support CR3 files
from the same API as everything else rather than forcing applications
to know while files might need a different API. Instead refactor
ExifIter to handle discontiguous regions of a file that have EXIF data.

Use this to handle CR3 files that spread EXIF data across multiple
boxes (CMT1, CMT2, CMT3). Update the CR3 test case to check that the
correct information is returned for the test file.

Author: rolandd

src/bbox/cr3_moov.rs

@@ -142,4 +142,24 @@ impl Cr3MoovBox {
         // For CR3, we primarily use CMT1 which contains the main EXIF IFD0 data
         self.uuid_canon_box.as_ref()?.exif_data_offset().cloned()
     }
+
+    /// Returns offset ranges for all CMT boxes (CMT1, CMT2, CMT3).
+    /// CMT1 is the primary EXIF data, CMT2 is ExifIFD data, CMT3 is MakerNotes.
+    pub fn all_cmt_data_offsets(&self) -> Vec<(&'static str, Range<usize>)> {
+        let Some(uuid_box) = self.uuid_canon_box.as_ref() else {
+            return Vec::new();
+        };
+
+        let mut offsets = Vec::with_capacity(3);
+        if let Some(range) = uuid_box.exif_data_offset() {
+            offsets.push(("CMT1", range.clone()));
+        }
+        if let Some(range) = uuid_box.cmt2_data_offset() {
+            offsets.push(("CMT2", range.clone()));
+        }
+        if let Some(range) = uuid_box.cmt3_data_offset() {
+            offsets.push(("CMT3", range.clone()));
+        }
+        offsets
+    }
 }

src/cr3.rs

@@ -1,3 +1,5 @@
+use std::ops::Range;
+
 use nom::IResult;
 
 use crate::{
@@ -11,6 +13,54 @@ pub(crate) fn parse_moov_box(input: &[u8]) -> IResult<&[u8], Option<Cr3MoovBox>>
     Cr3MoovBox::parse(input)
 }
 
+/// Result containing all CMT ranges for CR3 files.
+/// Each tuple contains (block_id, data_range).
+#[derive(Debug, Clone)]
+pub(crate) struct Cr3CmtRanges {
+    /// All CMT ranges: (block_id, range)
+    pub ranges: Vec<(&'static str, Range<usize>)>,
+}
+
+/// Extract all CMT data ranges from a CR3 file buffer.
+/// Returns the moov box and all CMT ranges if available.
+pub(crate) fn extract_all_cmt_ranges(
+    buf: &[u8],
+) -> Result<Option<Cr3CmtRanges>, ParsingErrorState> {
+    let (_, moov) =
+        parse_moov_box(buf).map_err(|e| nom_error_to_parsing_error_with_state(e, None))?;
+
+    let Some(moov) = moov else {
+        return Ok(None);
+    };
+
+    let ranges = moov.all_cmt_data_offsets();
+    if ranges.is_empty() {
+        return Err(ParsingErrorState::new(
+            ParsingError::Failed(
+                "CR3 file contains no EXIF data: Canon UUID box found but no CMT offsets available"
+                    .into(),
+            ),
+            None,
+        ));
+    }
+
+    // Validate all ranges are within buffer bounds
+    for (block_id, range) in &ranges {
+        if range.end > buf.len() {
+            // For now, we'll skip validation and let it fail later if needed
+            // This matches the behavior of the original extract_exif_data
+            tracing::warn!(
+                block_id,
+                range_end = range.end,
+                buf_len = buf.len(),
+                "CMT range extends beyond buffer"
+            );
+        }
+    }
+
+    Ok(Some(Cr3CmtRanges { ranges }))
+}
+
 pub(crate) fn extract_exif_data(
     state: Option<ParsingState>,
     buf: &[u8],

src/exif.rs

@@ -12,7 +12,6 @@ use exif_exif::TIFF_HEADER_LEN;
 use exif_iter::input_into_iter;
 pub use exif_iter::{ExifIter, ParsedExifEntry};
 pub use gps::{GPSInfo, LatLng};
-pub use multi_exif::{DuplicateStrategy, MultiExifIter};
 pub use tags::ExifTag;
 
 use std::io::Read;
@@ -25,7 +24,6 @@ pub(crate) use travel::IfdHeaderTravel;
 mod exif_exif;
 mod exif_iter;
 mod gps;
-mod multi_exif;
 mod tags;
 mod travel;
 
@@ -74,44 +72,85 @@ pub(crate) fn parse_exif_iter<R: Read, S: Skip<R>>(
     mime_img: MimeImage,
     reader: &mut R,
 ) -> Result<ExifIter, crate::Error> {
+    // For CR3 files, we need special handling to get all CMT blocks
+    if mime_img == MimeImage::Cr3 {
+        return parse_cr3_exif_iter::<R, S>(parser, reader);
+    }
+
     let out = parser.load_and_parse::<R, S, _, _>(reader, |buf, state| {
         extract_exif_range(mime_img, buf, state)
     })?;
 
     range_to_iter(parser, out)
 }
 
+/// Special parser for CR3 files that extracts all CMT blocks (CMT1, CMT2, CMT3)
+/// and adds them as additional TIFF blocks to the ExifIter.
 #[tracing::instrument(skip(reader))]
-pub(crate) fn parse_multi_exif_iter<R: Read, S: Skip<R>>(
+fn parse_cr3_exif_iter<R: Read, S: Skip<R>>(
     parser: &mut MediaParser,
-    mime_img: MimeImage,
     reader: &mut R,
-) -> Result<MultiExifIter, crate::Error> {
-    if mime_img != MimeImage::Cr3 {
-        return Err(format!("MultiExifIter is not supported for {mime_img:?}").into());
-    }
+) -> Result<ExifIter, crate::Error> {
+    use crate::parser::Buf;
 
-    let mut iter = MultiExifIter::new(DuplicateStrategy::IgnoreDuplicates);
+    // First, parse to get all CMT ranges
+    let cmt_ranges = parser.load_and_parse::<R, S, _, _>(reader, |buf, _state| {
+        cr3::extract_all_cmt_ranges(buf)
+    })?;
 
-    // TODO: The following is only demonstration code.
-    // Please make further modifications based on the CR3 file structure.
-    // For example, the `parse` callback of `load_and_parse` should be reimplemented
-    // to correctly parse the next CMT* box.
+    let Some(cmt_ranges) = cmt_ranges else {
+        return Err("CR3: No CMT data found".into());
+    };
 
-    loop {
-        let out = parser.load_and_parse::<R, S, _, _>(reader, |buf, state| {
-            extract_exif_range(mime_img, buf, state)
-        })?;
-        if out.is_none() {
-            break;
+    if cmt_ranges.ranges.is_empty() {
+        return Err("CR3: No CMT ranges available".into());
+    }
+
+    tracing::debug!(
+        cmt_count = cmt_ranges.ranges.len(),
+        "Found CMT ranges in CR3 file"
+    );
+
+    // Get the parser position offset - share_buf will add this to ranges
+    let position_offset = parser.position();
+
+    // Get the first CMT range (CMT1) to create the primary ExifIter
+    let (first_block_id, first_range) = &cmt_ranges.ranges[0];
+    tracing::debug!(
+        block_id = first_block_id,
+        range = ?first_range,
+        position_offset,
+        "Creating primary ExifIter from first CMT block"
+    );
+
+    // Share the buffer and create the primary ExifIter
+    // Note: share_buf adds position_offset to the range internally
+    let input: PartialVec = parser.share_buf(first_range.clone());
+    let mut iter = input_into_iter(input, None)?;
+
+    // Add remaining CMT blocks as additional TIFF blocks
+    // We need to adjust the ranges by position_offset since the PartialVec.data
+    // contains the full buffer and ranges need to be absolute
+    // Note: We skip CMT3 (MakerNotes) as it has a proprietary format that requires
+    // special handling and would produce garbage data if parsed as standard EXIF
+    for (block_id, range) in cmt_ranges.ranges.iter().skip(1) {
+        // Skip CMT3 (MakerNotes) - it has a proprietary Canon format
+        if *block_id == "CMT3" {
+            tracing::debug!(
+                block_id,
+                "Skipping CMT3 (MakerNotes) - proprietary format"
+            );
+            continue;
         }
 
-        // TODO: The current `block_id` should be returned via the `load_and_parse` call.
-        let block_id = "CMT1";
-        let data = out
-            .map(|(range, _)| parser.share_buf(range))
-            .ok_or_else(|| format!("Exif not found in block {block_id}"))?;
-        iter.add_tiff_data(block_id.to_owned(), data, None);
+        let adjusted_range = (range.start + position_offset)..(range.end + position_offset);
+        tracing::debug!(
+            block_id,
+            original_range = ?range,
+            adjusted_range = ?adjusted_range,
+            "Adding additional CMT block"
+        );
+        iter.add_tiff_block(block_id.to_string(), adjusted_range, None);
     }
 
     Ok(iter)