Support unknown (zero) sized mdat boxes in AVIF.

Author: kinetiknz

mp4parse/src/lib.rs

@@ -2275,7 +2275,7 @@ impl<'a, T: Read> BoxIter<'a, T> {
         match r {
             Ok(h) => Ok(Some(BMFFBox {
                 head: h,
-                content: self.src.take(h.size - h.offset),
+                content: self.src.take(h.size.saturating_sub(h.offset)),
             })),
             Err(Error::UnexpectedEOF) => Ok(None),
             Err(e) => Err(e),
@@ -2337,7 +2337,13 @@ fn read_box_header<T: ReadBytesExt>(src: &mut T) -> Result<BoxHeader> {
     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 => return Err(Error::Unsupported("unknown sized box")),
+        0 => {
+            if name == BoxType::MediaDataBox {
+                0
+            } else {
+                return Err(Error::Unsupported("unknown sized box"));
+            }
+        }
         1 => {
             let size64 = be_u64(src)?;
             if size64 < BoxHeader::MIN_LARGE_SIZE {
@@ -2375,7 +2381,7 @@ fn read_box_header<T: ReadBytesExt>(src: &mut T) -> Result<BoxHeader> {
     } else {
         None
     };
-    assert!(offset <= size);
+    assert!(offset <= size || size == 0);
     Ok(BoxHeader {
         name,
         size,
@@ -2536,7 +2542,26 @@ pub fn read_avif<T: Read>(f: &mut T, strictness: ParseStrictness) -> Result<Avif
             }
             BoxType::MediaDataBox => {
                 let file_offset = b.offset();
-                let data = b.read_into_try_vec()?;
+                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))?;
             }
             _ => skip_box_content(&mut b)?,

mp4parse/tests/public.rs

@@ -65,6 +65,7 @@ static IMAGE_AVIF_IMIR_MISSING_ESSENTIAL: &str = "tests/imir-missing-essential.a
 static IMAGE_AVIF_IROT_MISSING_ESSENTIAL: &str = "tests/irot-missing-essential.avif";
 static IMAGE_AVIF_LSEL_MISSING_ESSENTIAL: &str = "tests/corrupt/lsel-missing-essential.avif";
 static IMAGE_AVIF_CLAP_MISSING_ESSENTIAL: &str = "tests/clap-missing-essential.avif";
+static IMAGE_AVIF_UNKNOWN_MDAT_SIZE: &str = "tests/unknown_mdat.avif";
 static AVIF_TEST_DIRS: &[&str] = &["tests", "av1-avif/testFiles", "link-u-avif-sample-images"];
 
 // These files are
@@ -910,6 +911,19 @@ fn public_avif_alpha_premultiplied() {
     });
 }
 
+#[test]
+fn public_avif_unknown_mdat() {
+    let input = &mut File::open(IMAGE_AVIF_UNKNOWN_MDAT_SIZE).expect("Unknown file");
+    let context = mp4::read_avif(input, ParseStrictness::Normal).expect("read_avif failed");
+    assert_eq!(
+        context.primary_item_coded_data().unwrap(),
+        [
+            0x12, 0x00, 0x0A, 0x07, 0x38, 0x00, 0x06, 0x90, 0x20, 0x20, 0x69, 0x32, 0x0C, 0x16,
+            0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x79, 0x4C, 0xD2, 0x02
+        ]
+    );
+}
+
 #[test]
 fn public_avif_bug_1655846() {
     let input = &mut File::open(IMAGE_AVIF_CORRUPT).expect("Unknown file");