Read the loop count from AVIS files.

The loop count is calculated as the number of times the animation must play to fill the `trak` duration based on the actual animation duration stored in the `elst` box.

Author: Zaggy1024

mp4parse/src/lib.rs

@@ -988,6 +988,7 @@ pub struct TrackHeaderBox {
 /// Edit list box 'elst'
 #[derive(Debug)]
 struct EditListBox {
+    looped: bool,
     edits: TryVec<Edit>,
 }
 
@@ -2242,7 +2243,9 @@ where
 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>>,
@@ -4402,6 +4405,8 @@ fn read_edts<T: Read>(f: &mut BMFFBox<T>, track: &mut Track) -> Result<()> {
                 if media_time < 0 {
                     debug!("unexpected negative media time in edit");
                 }
+                track.looped = Some(elst.looped);
+                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,
@@ -4668,7 +4673,7 @@ fn read_tkhd<T: Read>(src: &mut BMFFBox<T>) -> Result<TrackHeaderBox> {
 /// 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, _) = read_fullbox_extra(src)?;
+    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 {
@@ -4696,7 +4701,10 @@ fn read_elst<T: Read>(src: &mut BMFFBox<T>) -> Result<EditListBox> {
     // Padding could be added in some contents.
     skip_box_remain(src)?;
 
-    Ok(EditListBox { edits })
+    Ok(EditListBox {
+        looped: flags == 1,
+        edits,
+    })
 }
 
 /// Parse a mdhd box.

mp4parse/tests/loop_forever.avif

@@ -86,6 +86,8 @@ static AVIF_AVIS_MAJOR_NO_PITM: &str =
 /// but with https://github.com/AOMediaCodec/av1-avif/issues/177 fixed
 static AVIF_AVIS_MAJOR_WITH_PITM_AND_ALPHA: &str = "tests/alpha_video_fixed.avif";
 static AVIF_AVIS_MAJOR_NO_MOOV: &str = "tests/corrupt/alpha_video_moov_is_moop.avif";
+static AVIF_AVIS_NO_LOOP: &str = "tests/loop_none.avif";
+static AVIF_AVIS_LOOP_FOREVER: &str = "tests/loop_forever.avif";
 static AVIF_NO_PIXI_IMAGES: &[&str] = &[IMAGE_AVIF_NO_PIXI, IMAGE_AVIF_NO_ALPHA_PIXI];
 static AVIF_UNSUPPORTED_IMAGES: &[&str] = &[
     AVIF_A1LX,
@@ -1207,7 +1209,13 @@ fn public_avis_major_with_pitm_and_alpha() {
             assert_eq!(context.major_brand, mp4::AVIS_BRAND);
             assert!(context.primary_item_coded_data().is_some());
             assert!(context.alpha_item_coded_data().is_some());
-            assert!(context.sequence.is_some());
+            match context.sequence {
+                Some(sequence) => {
+                    assert!(!sequence.tracks.is_empty());
+                    assert_eq!(sequence.tracks[0].looped, None);
+                }
+                None => panic!("Expected sequence"),
+            }
         }
         Err(e) => panic!("Expected Ok(_), found {:?}", e),
     }
@@ -1218,6 +1226,36 @@ fn public_avif_avis_major_no_moov() {
     assert_avif_shall(AVIF_AVIS_MAJOR_NO_MOOV, Status::MoovMissing);
 }
 
+fn public_avis_loop_impl(path: &str, looped: bool) {
+    let input = &mut File::open(path).expect("Unknown file");
+    match mp4::read_avif(input, ParseStrictness::Normal) {
+        Ok(context) => match context.sequence {
+            Some(sequence) => {
+                assert!(!sequence.tracks.is_empty());
+                assert_eq!(sequence.tracks[0].looped, Some(looped));
+                if looped {
+                    assert!(sequence.tracks[0].edited_duration.is_some());
+                }
+            }
+            None => panic!(
+                "Expected sequence in {}",
+                AVIF_AVIS_MAJOR_WITH_PITM_AND_ALPHA
+            ),
+        },
+        Err(e) => panic!("Expected Ok(_), found {:?}", e),
+    }
+}
+
+#[test]
+fn public_avif_avis_no_loop() {
+    public_avis_loop_impl(AVIF_AVIS_NO_LOOP, false);
+}
+
+#[test]
+fn public_avif_avis_loop_forever() {
+    public_avis_loop_impl(AVIF_AVIS_LOOP_FOREVER, true);
+}
+
 #[test]
 fn public_avif_read_samples() {
     public_avif_read_samples_impl(ParseStrictness::Normal);

mp4parse/tests/loop_none.avif

@@ -312,6 +312,20 @@ pub struct Mp4parseParser {
     video_track_sample_descriptions: TryHashMap<u32, TryVec<Mp4parseTrackVideoSampleInfo>>,
 }
 
+#[repr(C)]
+#[derive(Debug)]
+pub enum Mp4parseAvifLoopMode {
+    NoEdits,
+    LoopByCount,
+    LoopInfinitely,
+}
+
+impl Default for Mp4parseAvifLoopMode {
+    fn default() -> Self {
+        Mp4parseAvifLoopMode::NoEdits
+    }
+}
+
 #[repr(C)]
 #[derive(Debug)]
 pub struct Mp4parseAvifInfo {
@@ -338,6 +352,14 @@ pub struct Mp4parseAvifInfo {
 
     /// Whether there is a sequence. Can be true with no primary image.
     pub has_sequence: bool,
+    /// Indicates whether the EditListBox requests that the image be looped.
+    pub loop_mode: Mp4parseAvifLoopMode,
+    /// Number of times to loop the animation during playback.
+    ///
+    /// The duration of the animation specified in `elst` must be looped to fill the
+    /// duration of the color track. If the resulting loop count is not an integer,
+    /// then it will be ceiled to play past and fill the entire track's duration.
+    pub loop_count: u64,
     /// The color track's ID, which must be valid if has_sequence is true.
     pub color_track_id: u32,
     pub color_track_bit_depth: u8,
@@ -1096,6 +1118,8 @@ fn mp4parse_avif_get_info_safe(context: &AvifContext) -> mp4parse::Result<Mp4par
         alpha_item_bit_depth: 0,
 
         has_sequence: false,
+        loop_mode: Mp4parseAvifLoopMode::NoEdits,
+        loop_count: 0,
         color_track_id: 0,
         color_track_bit_depth: 0,
         alpha_track_id: 0,
@@ -1182,10 +1206,38 @@ fn mp4parse_avif_get_info_safe(context: &AvifContext) -> mp4parse::Result<Mp4par
             _ => (0, 0),
         };
 
+        let (loop_mode, loop_count) = match color_track.tkhd.as_ref().map(|tkhd| tkhd.duration) {
+            Some(movie_duration) if movie_duration == std::u64::MAX => {
+                (Mp4parseAvifLoopMode::LoopInfinitely, 0)
+            }
+            Some(movie_duration) => match color_track.looped {
+                Some(true) => match color_track.edited_duration.map(|v| v.0) {
+                    Some(segment_duration) => {
+                        match movie_duration.checked_div(segment_duration).and_then(|n| {
+                            match movie_duration.checked_rem(segment_duration) {
+                                Some(0) => Some(n.saturating_sub(1)),
+                                Some(_) => Some(n),
+                                None => None,
+                            }
+                        }) {
+                            Some(n) => (Mp4parseAvifLoopMode::LoopByCount, n),
+                            None => (Mp4parseAvifLoopMode::LoopInfinitely, 0),
+                        }
+                    }
+                    None => (Mp4parseAvifLoopMode::NoEdits, 0),
+                },
+                Some(false) => (Mp4parseAvifLoopMode::LoopByCount, 0),
+                None => (Mp4parseAvifLoopMode::NoEdits, 0),
+            },
+            None => (Mp4parseAvifLoopMode::LoopInfinitely, 0),
+        };
+
         return Ok(Mp4parseAvifInfo {
             primary_item_bit_depth,
             alpha_item_bit_depth,
             has_sequence: true,
+            loop_mode,
+            loop_count,
             color_track_id,
             color_track_bit_depth,
             alpha_track_id,