always use version1 in ctts table parsing and adjust the composition time calculation

Author: alfredoyang

mp4parse/src/lib.rs

@@ -1165,12 +1165,10 @@ fn read_ctts<T: Read>(src: &mut BMFFBox<T>) -> Result<CompositionOffsetBox> {
     let mut offsets = Vec::new();
     for _ in 0..counts {
         let (sample_count, time_offset) = match version {
-            0 => {
-                let count = be_u32(src)?;
-                let offset = TimeOffsetVersion::Version0(be_u32(src)?);
-                (count, offset)
-            },
-            1 => {
+            // According to spec, Version0 shoule be used when version == 0;
+            // however, some buggy contents have negative value when version == 0.
+            // So we always use Version1 here.
+            0...1 => {
                 let count = be_u32(src)?;
                 let offset = TimeOffsetVersion::Version1(be_i32(src)?);
                 (count, offset)

mp4parse_capi/src/lib.rs

@@ -398,6 +398,15 @@ fn track_time_to_us(time: TrackScaledTime, scale: TrackTimeScale) -> Option<u64>
     rational_scale(time.0, scale.0, microseconds_per_second)
 }
 
+fn get_track_time_to_us(time: i64, scale: TrackTimeScale) -> i64 {
+    assert!(time >= 0);
+    let track_time = TrackScaledTime(time as u64, scale.1);
+    match track_time_to_us(track_time, scale) {
+        Some(v) => v as i64,
+        _ => 0,
+    }
+}
+
 /// Fill the supplied `mp4parse_track_info` with metadata for `track`.
 #[no_mangle]
 pub unsafe extern fn mp4parse_get_track_info(parser: *mut mp4parse_parser, track_index: u32, info: *mut mp4parse_track_info) -> mp4parse_error {
@@ -856,29 +865,6 @@ impl<'a> Iterator for SampleToChunkIterator<'a> {
     }
 }
 
-// A helper struct to convert track time to us.
-struct PresentationTime {
-    time: i64,
-    scale: TrackTimeScale
-}
-
-impl PresentationTime {
-    fn new(time: i64, scale: TrackTimeScale) -> PresentationTime {
-        PresentationTime {
-            time: time,
-            scale: scale,
-        }
-    }
-
-    fn to_us(&self) -> i64 {
-        let track_time = TrackScaledTime(self.time as u64, self.scale.1);
-        match track_time_to_us(track_time, self.scale) {
-            Some(v) => v as i64,
-            _ => 0,
-        }
-    }
-}
-
 fn create_sample_table(track: &Track, track_offset_time: i64) -> Option<Vec<mp4parse_indice>> {
     let timescale = match track.timescale {
         Some(t) => t,
@@ -971,18 +957,22 @@ fn create_sample_table(track: &Track, track_offset_time: i64) -> Option<Vec<mp4p
     //      composition time => CT(n) = DT(n) + CTTS(n)
     // Note:
     //      composition time needs to add the track offset time from 'elst' table.
-    let mut sum_delta = PresentationTime::new(0, timescale);
+    let mut sum_delta = 0;
     for sample in sample_table.as_mut_slice() {
-        let decode_time = sum_delta.to_us();
-        sum_delta.time += stts_iter.next_delta() as i64;
+        let decode_time = sum_delta;
+        sum_delta += stts_iter.next_delta() as i64;
 
         // ctts_offset is the current sample offset time.
-        let ctts_offset = PresentationTime::new(ctts_offset_iter.next_offset_time(), timescale);
+        let ctts_offset = ctts_offset_iter.next_offset_time();
 
-        let start_composition = decode_time + ctts_offset.to_us() + track_offset_time;
-        let end_composition = sum_delta.to_us() + ctts_offset.to_us() + track_offset_time;
+        // ctts_offset could be negative but (decode_time + ctts_offset) should always be positive
+        // value.
+        let start_composition = get_track_time_to_us(decode_time + ctts_offset, timescale) + track_offset_time;
+        // ctts_offset could be negative but (sum_delta + ctts_offset) should always be positive
+        // value.
+        let end_composition = get_track_time_to_us(sum_delta + ctts_offset, timescale) + track_offset_time;
 
-        sample.start_decode = decode_time;
+        sample.start_decode = get_track_time_to_us(decode_time, timescale);;
         sample.start_composition = start_composition;
         sample.end_composition = end_composition;
     }

mp4parse_capi/tests/test_sample_table.rs

@@ -151,3 +151,58 @@ fn parse_sample_table_with_elst() {
         mp4parse_free(parser);
     }
 }
+
+#[test]
+fn parse_sample_table_with_negative_ctts() {
+    let mut file = std::fs::File::open("tests/white.mp4").expect("Unknown file");
+    let io = mp4parse_io {
+        read: buf_read,
+        userdata: &mut file as *mut _ as *mut std::os::raw::c_void
+    };
+
+    unsafe {
+        let parser = mp4parse_new(&io);
+
+        let mut rv = mp4parse_read(parser);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+
+        let mut counts: u32 = 0;
+        rv = mp4parse_get_track_count(parser, &mut counts);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+        assert_eq!(counts, 1);
+
+        let mut track_info = mp4parse_track_info {
+            track_type: mp4parse_track_type::MP4PARSE_TRACK_TYPE_AUDIO,
+            codec: mp4parse_codec::MP4PARSE_CODEC_UNKNOWN,
+            track_id: 0,
+            duration: 0,
+            media_time: 0,
+        };
+        rv = mp4parse_get_track_info(parser, 0, &mut track_info);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+        assert_eq!(track_info.track_type, mp4parse_track_type::MP4PARSE_TRACK_TYPE_VIDEO);
+        assert_eq!(track_info.codec, mp4parse_codec::MP4PARSE_CODEC_AVC);
+
+        let mut is_fragmented_file: u8 = std::u8::MAX;
+        rv = mp4parse_is_fragmented(parser, track_info.track_id, &mut is_fragmented_file);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+        assert_eq!(is_fragmented_file, 0);
+
+        let mut indice = mp4parse_byte_data::default();
+        rv = mp4parse_get_indice_table(parser, track_info.track_id, &mut indice);
+        assert_eq!(rv, mp4parse_error::MP4PARSE_OK);
+
+        // There are negative value in 'ctts' table.
+        let video_indice_0 = mp4parse_indice { start_offset: 48, end_offset: 890, start_composition: 0, end_composition: 33333, start_decode: 0, sync: true };
+        let video_indice_1 = mp4parse_indice { start_offset: 890, end_offset: 913, start_composition: 133333, end_composition: 166666, start_decode: 33333, sync: false };
+        let video_indice_2 = mp4parse_indice { start_offset: 913, end_offset: 934, start_composition: 66666, end_composition: 100000, start_decode: 66666, sync: false };
+        let video_indice_3 = mp4parse_indice { start_offset: 934, end_offset: 955, start_composition: 33333, end_composition: 66666, start_decode: 100000, sync: false };
+        assert_eq!(indice.length, 300);
+        assert_eq!(*indice.indices.offset(0), video_indice_0);
+        assert_eq!(*indice.indices.offset(1), video_indice_1);
+        assert_eq!(*indice.indices.offset(2), video_indice_2);
+        assert_eq!(*indice.indices.offset(3), video_indice_3);
+
+        mp4parse_free(parser);
+    }
+}