Expose time in ticks relative to a timebase and not in microseconds

Author: padenot

mp4parse/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mp4parse"
-version = "0.16.0"
+version = "0.17.0"
 authors = [
   "Ralph Giles <[email protected]>",
   "Matthew Gregan <[email protected]>",

mp4parse/src/unstable.rs

@@ -115,14 +115,14 @@ pub struct Indice {
     /// sample. Typically this will be the `start_offset` of the next sample
     /// in the file.
     pub end_offset: CheckedInteger<u64>,
-    /// The time in microseconds when the indexed sample should be displayed.
+    /// The time in ticks when the indexed sample should be displayed.
     /// Analogous to the concept of presentation time stamp (pts).
     pub start_composition: CheckedInteger<i64>,
-    /// The time in microseconds when the indexed sample should stop being
+    /// The time in ticks when the indexed sample should stop being
     /// displayed. Typically this would be the `start_composition` time of the
     /// next sample if samples were ordered by composition time.
     pub end_composition: CheckedInteger<i64>,
-    /// The time in microseconds that the indexed sample should be decoded at.
+    /// The time in ticks that the indexed sample should be decoded at.
     /// Analogous to the concept of decode time stamp (dts).
     pub start_decode: CheckedInteger<i64>,
     /// Set if the indexed sample is a sync sample. The meaning of sync is
@@ -140,11 +140,6 @@ pub fn create_sample_table(
     track: &Track,
     track_offset_time: CheckedInteger<i64>,
 ) -> Option<TryVec<Indice>> {
-    let timescale = match track.timescale {
-        Some(ref t) => TrackTimeScale::<i64>(t.0 as i64, t.1),
-        _ => return None,
-    };
-
     let (stsc, stco, stsz, stts) = match (&track.stsc, &track.stco, &track.stsz, &track.stts) {
         (Some(a), Some(b), Some(c), Some(d)) => (a, b, c, d),
         _ => return None,
@@ -238,15 +233,15 @@ pub fn create_sample_table(
         // ctts_offset is the current sample offset time.
         let ctts_offset = ctts_offset_iter.next_offset_time();
 
-        let start_composition = track_time_to_us((decode_time + ctts_offset)?, timescale)?.0;
+        let start_composition = decode_time + ctts_offset;
 
-        let end_composition = track_time_to_us((sum_delta + ctts_offset)?, timescale)?.0;
+        let end_composition = sum_delta + ctts_offset;
 
-        let start_decode = track_time_to_us(decode_time, timescale)?.0;
+        let start_decode = decode_time;
 
-        sample.start_composition = (track_offset_time + start_composition)?;
-        sample.end_composition = (track_offset_time + end_composition)?;
-        sample.start_decode = start_decode.into();
+        sample.start_composition = CheckedInteger(track_offset_time.0 + start_composition?.0);
+        sample.end_composition = CheckedInteger(track_offset_time.0 + end_composition?.0);
+        sample.start_decode = CheckedInteger(start_decode.0);
     }
 
     // Correct composition end time due to 'ctts' causes composition time re-ordering.

mp4parse_capi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mp4parse_capi"
-version = "0.16.0"
+version = "0.17.0"
 authors = [
   "Ralph Giles <[email protected]>",
   "Matthew Gregan <[email protected]>",
@@ -27,7 +27,7 @@ travis-ci = { repository = "https://github.com/mozilla/mp4parse-rust" }
 byteorder = "1.2.1"
 fallible_collections = { version = "0.4", features = ["std_io"] }
 log = "0.4"
-mp4parse = { version = "0.16.0", path = "../mp4parse", features = ["unstable-api"] }
+mp4parse = { version = "0.17.0", path = "../mp4parse", features = ["unstable-api"] }
 num-traits = "0.2.14"
 
 [dev-dependencies]

mp4parse_capi/src/lib.rs

@@ -42,9 +42,7 @@ use std::io::Read;
 
 // Symbols we need from our rust api.
 use mp4parse::serialize_opus_header;
-use mp4parse::unstable::{
-    create_sample_table, media_time_to_us, track_time_to_us, CheckedInteger, Indice, Microseconds,
-};
+use mp4parse::unstable::{create_sample_table, CheckedInteger, Indice};
 use mp4parse::AV1ConfigBox;
 use mp4parse::AudioCodecSpecific;
 use mp4parse::AvifContext;
@@ -127,10 +125,8 @@ pub struct Mp4parseTrackInfo {
     pub track_type: Mp4parseTrackType,
     pub track_id: u32,
     pub duration: u64,
-    pub media_time: CheckedInteger<i64>, // wants to be u64? understand how elst adjustment works
-                                         // TODO(kinetik): include crypto guff
-                                         // If this changes to u64, we can get rid of the strange
-                                         // impl Sub for CheckedInteger<u64>
+    pub media_time: CheckedInteger<i64>,
+    pub time_scale: u32,
 }
 
 #[repr(C)]
@@ -278,9 +274,9 @@ impl Default for Mp4parseTrackVideoInfo {
 #[repr(C)]
 #[derive(Default, Debug)]
 pub struct Mp4parseFragmentInfo {
-    pub fragment_duration: u64,
-    // TODO:
-    // info in trex box.
+    pub fragment_duration: u64, // in ticks
+                                // TODO:
+                                // info in trex box.
 }
 
 #[derive(Default)]
@@ -631,46 +627,34 @@ pub unsafe extern "C" fn mp4parse_get_track_info(
 
     let track = &context.tracks[track_index];
 
-    if let (Some(track_timescale), Some(context_timescale)) = (track.timescale, context.timescale) {
-        let media_time: CheckedInteger<_> = match track
+    if let (Some(timescale), Some(_)) = (track.timescale, context.timescale) {
+        info.time_scale = timescale.0 as u32;
+        let media_time: CheckedInteger<u64> = track
             .media_time
-            .map_or(Some(Microseconds(0)), |media_time| {
-                track_time_to_us(media_time, track_timescale)
-            }) {
-            Some(time) => time.0.into(),
-            None => return Mp4parseStatus::Invalid,
-        };
-        let empty_duration: CheckedInteger<_> = match track
+            .map_or(0.into(), |media_time| media_time.0.into());
+
+        let empty_duration: CheckedInteger<u64> = track
             .empty_duration
-            .map_or(Some(Microseconds(0)), |empty_duration| {
-                media_time_to_us(empty_duration, context_timescale)
-            }) {
-            Some(time) => time.0.into(),
-            None => return Mp4parseStatus::Invalid,
-        };
+            .map_or(0.into(), |empty_duration| empty_duration.0.into());
+
         info.media_time = match media_time - empty_duration {
             Some(difference) => difference,
             None => return Mp4parseStatus::Invalid,
         };
 
-        if let Some(track_duration) = track.duration {
-            match track_time_to_us(track_duration, track_timescale) {
-                Some(duration) => info.duration = duration.0,
-                None => return Mp4parseStatus::Invalid,
+        match track.duration {
+            Some(duration) => info.duration = duration.0,
+            None => {
+                // Duration unknown; stagefright returns 0 for this.
+                info.duration = 0
             }
-        } else {
-            // Duration unknown; stagefright returns 0 for this.
-            info.duration = 0
         }
-    } else {
-        return Mp4parseStatus::Invalid;
-    }
+    };
 
     info.track_id = match track.track_id {
         Some(track_id) => track_id,
         None => return Mp4parseStatus::Invalid,
     };
-
     Mp4parseStatus::Ok
 }
 
@@ -1355,20 +1339,15 @@ fn get_indice_table(
         return Ok(());
     }
 
-    let media_time = match (&track.media_time, &track.timescale) {
-        (&Some(t), &Some(s)) => track_time_to_us(t, s)
-            .and_then(|v| i64::try_from(v.0).ok())
-            .map(Into::into),
+    let media_time = match &track.media_time {
+        &Some(t) => i64::try_from(t.0).ok().map(Into::into),
         _ => None,
     };
 
-    let empty_duration: Option<CheckedInteger<_>> =
-        match (&track.empty_duration, &context.timescale) {
-            (&Some(e), &Some(s)) => media_time_to_us(e, s)
-                .and_then(|v| i64::try_from(v.0).ok())
-                .map(Into::into),
-            _ => None,
-        };
+    let empty_duration: Option<CheckedInteger<_>> = match &track.empty_duration {
+        &Some(e) => i64::try_from(e.0).ok().map(Into::into),
+        _ => None,
+    };
 
     // Find the track start offset time from 'elst'.
     // 'media_time' maps start time onward, 'empty_duration' adds time offset
@@ -1420,12 +1399,12 @@ pub unsafe extern "C" fn mp4parse_get_fragment_info(
         None => return Mp4parseStatus::Invalid,
     };
 
-    if let (Some(time), Some(scale)) = (duration, context.timescale) {
-        info.fragment_duration = match media_time_to_us(time, scale) {
-            Some(time_us) => time_us.0,
-            None => return Mp4parseStatus::Invalid,
+    match duration {
+        Some(duration_ticks) => {
+            info.fragment_duration = duration_ticks.0;
         }
-    }
+        None => return Mp4parseStatus::Invalid,
+    };
 
     Mp4parseStatus::Ok
 }
@@ -1741,16 +1720,16 @@ fn minimal_mp4_get_track_info() {
     });
     assert_eq!(info.track_type, Mp4parseTrackType::Video);
     assert_eq!(info.track_id, 1);
-    assert_eq!(info.duration, 40000);
+    assert_eq!(info.duration, 512);
     assert_eq!(info.media_time, 0);
 
     assert_eq!(Mp4parseStatus::Ok, unsafe {
         mp4parse_get_track_info(parser, 1, &mut info)
     });
     assert_eq!(info.track_type, Mp4parseTrackType::Audio);
     assert_eq!(info.track_id, 2);
-    assert_eq!(info.duration, 61333);
-    assert_eq!(info.media_time, 21333);
+    assert_eq!(info.duration, 2944);
+    assert_eq!(info.media_time, 1024);
 
     unsafe {
         mp4parse_free(parser);

mp4parse_capi/tests/test_fragment.rs

@@ -36,6 +36,7 @@ fn parse_fragment() {
         assert_eq!(track_info.track_id, 1);
         assert_eq!(track_info.duration, 0);
         assert_eq!(track_info.media_time, 0);
+        assert_eq!(track_info.time_scale, 22050);
 
         let mut audio = Default::default();
         rv = mp4parse_get_track_audio_info(parser, 0, &mut audio);
@@ -57,7 +58,7 @@ fn parse_fragment() {
         let mut fragment_info = Mp4parseFragmentInfo::default();
         rv = mp4parse_get_fragment_info(parser, &mut fragment_info);
         assert_eq!(rv, Mp4parseStatus::Ok);
-        assert_eq!(fragment_info.fragment_duration, 10_032_000);
+        assert_eq!(fragment_info.fragment_duration, 10_032);
 
         mp4parse_free(parser);
     }
@@ -89,6 +90,7 @@ fn parse_opus_fragment() {
         assert_eq!(track_info.track_id, 1);
         assert_eq!(track_info.duration, 0);
         assert_eq!(track_info.media_time, 0);
+        assert_eq!(track_info.time_scale, 48000);
 
         let mut audio = Default::default();
         rv = mp4parse_get_track_audio_info(parser, 0, &mut audio);