Make time conversion functions return newtype Microseconds<T> to help avoid unit-mixing mistakes

Author: Adrian

mp4parse/src/unstable.rs

@@ -239,11 +239,11 @@ 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)?;
+        let start_composition = track_time_to_us((decode_time + ctts_offset)?, timescale)?.0;
 
-        let end_composition = track_time_to_us((sum_delta + ctts_offset)?, timescale)?;
+        let end_composition = track_time_to_us((sum_delta + ctts_offset)?, timescale)?.0;
 
-        let start_decode = track_time_to_us(decode_time, timescale)?;
+        let start_decode = track_time_to_us(decode_time, timescale)?.0;
 
         sample.start_composition = (track_offset_time + start_composition)?;
         sample.end_composition = (track_offset_time + end_composition)?;
@@ -490,22 +490,30 @@ where
     })
 }
 
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Microseconds<T>(pub T);
+
 /// Convert `time` in media's global (mvhd) timescale to microseconds,
 /// using provided `MediaTimeScale`
-pub fn media_time_to_us(time: MediaScaledTime, scale: MediaTimeScale) -> Option<u64> {
+pub fn media_time_to_us(time: MediaScaledTime, scale: MediaTimeScale) -> Option<Microseconds<u64>> {
     let microseconds_per_second = 1_000_000;
     rational_scale::<u64, u64>(time.0, scale.0, microseconds_per_second)
+        .and_then(|v| Some(Microseconds(v)))
 }
 
 /// Convert `time` in track's local (mdhd) timescale to microseconds,
 /// using provided `TrackTimeScale<T>`
-pub fn track_time_to_us<T>(time: TrackScaledTime<T>, scale: TrackTimeScale<T>) -> Option<T>
+pub fn track_time_to_us<T>(
+    time: TrackScaledTime<T>,
+    scale: TrackTimeScale<T>,
+) -> Option<Microseconds<T>>
 where
     T: PrimInt + Zero,
 {
     assert_eq!(time.1, scale.1);
     let microseconds_per_second = 1_000_000;
     rational_scale::<T, u64>(time.0, scale.0, microseconds_per_second)
+        .and_then(|v| Some(Microseconds(v)))
 }
 
 #[test]
@@ -526,7 +534,7 @@ fn media_time_overflow() {
     let duration = MediaScaledTime(9_007_199_254_710_000);
     assert_eq!(
         media_time_to_us(duration, scale),
-        Some(100_079_991_719_000_000)
+        Some(Microseconds(100_079_991_719_000_000u64))
     );
 }
 
@@ -536,6 +544,6 @@ fn track_time_overflow() {
     let duration = TrackScaledTime(4_413_527_634_807_900u64, 0);
     assert_eq!(
         track_time_to_us(duration, scale),
-        Some(100_079_991_719_000_000)
+        Some(Microseconds(100_079_991_719_000_000u64))
     );
 }

mp4parse_capi/src/lib.rs

@@ -621,27 +621,31 @@ 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.media_time.map_or(Some(0), |media_time| {
-            mp4parse::unstable::track_time_to_us(media_time, track_timescale)
-        }) {
-            Some(time) => time.into(),
+        let media_time: CheckedInteger<u64> = match track
+            .media_time
+            .map_or(Some(mp4parse::unstable::Microseconds(0)), |media_time| {
+                mp4parse::unstable::track_time_to_us(media_time, track_timescale)
+            }) {
+            Some(time) => time.0.into(),
             None => return Mp4parseStatus::Invalid,
         };
-        let empty_duration: CheckedInteger<_> =
-            match track.empty_duration.map_or(Some(0), |empty_duration| {
+        let empty_duration: CheckedInteger<u64> = match track.empty_duration.map_or(
+            Some(mp4parse::unstable::Microseconds(0)),
+            |empty_duration| {
                 mp4parse::unstable::media_time_to_us(empty_duration, context_timescale)
-            }) {
-                Some(time) => time.into(),
-                None => return Mp4parseStatus::Invalid,
-            };
+            },
+        ) {
+            Some(time) => time.0.into(),
+            None => return Mp4parseStatus::Invalid,
+        };
         info.media_time = match media_time - empty_duration {
             Some(difference) => difference,
             None => return Mp4parseStatus::Invalid,
         };
 
         if let Some(track_duration) = track.duration {
             match mp4parse::unstable::track_time_to_us(track_duration, track_timescale) {
-                Some(duration) => info.duration = duration,
+                Some(duration) => info.duration = duration.0,
                 None => return Mp4parseStatus::Invalid,
             }
         } else {
@@ -1111,15 +1115,15 @@ fn get_indice_table(
 
     let media_time = match (&track.media_time, &track.timescale) {
         (&Some(t), &Some(s)) => mp4parse::unstable::track_time_to_us(t, s)
-            .and_then(|v| i64::try_from(v).ok())
+            .and_then(|v| i64::try_from(v.0).ok())
             .map(Into::into),
         _ => None,
     };
 
     let empty_duration: Option<CheckedInteger<_>> =
         match (&track.empty_duration, &context.timescale) {
             (&Some(e), &Some(s)) => mp4parse::unstable::media_time_to_us(e, s)
-                .and_then(|v| i64::try_from(v).ok())
+                .and_then(|v| i64::try_from(v.0).ok())
                 .map(Into::into),
             _ => None,
         };
@@ -1176,7 +1180,7 @@ pub unsafe extern "C" fn mp4parse_get_fragment_info(
 
     if let (Some(time), Some(scale)) = (duration, context.timescale) {
         info.fragment_duration = match mp4parse::unstable::media_time_to_us(time, scale) {
-            Some(time_us) => time_us as u64,
+            Some(time_us) => time_us.0 as u64,
             None => return Mp4parseStatus::Invalid,
         }
     }