- Removed turbofish in media_time_to_us/track_time_to_us

- Added `use` of symbols from `unstable` mod at the beginning
- Removed unneded derives from `Microseconds`

Author: Adrian

mp4parse/src/unstable.rs

@@ -490,14 +490,14 @@ where
     })
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, PartialEq)]
 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<Microseconds<u64>> {
     let microseconds_per_second = 1_000_000;
-    rational_scale::<u64, u64>(time.0, scale.0, microseconds_per_second).map(Microseconds)
+    rational_scale(time.0, scale.0, microseconds_per_second).map(Microseconds)
 }
 
 /// Convert `time` in track's local (mdhd) timescale to microseconds,
@@ -511,7 +511,7 @@ where
 {
     assert_eq!(time.1, scale.1);
     let microseconds_per_second = 1_000_000;
-    rational_scale::<T, u64>(time.0, scale.0, microseconds_per_second).map(Microseconds)
+    rational_scale(time.0, scale.0, microseconds_per_second).map(Microseconds)
 }
 
 #[test]

mp4parse_capi/src/lib.rs

@@ -48,8 +48,9 @@ use std::io::Read;
 
 // Symbols we need from our rust api.
 use mp4parse::serialize_opus_header;
-use mp4parse::unstable::CheckedInteger;
-use mp4parse::unstable::Indice;
+use mp4parse::unstable::{
+    create_sample_table, media_time_to_us, track_time_to_us, CheckedInteger, Indice, Microseconds,
+};
 use mp4parse::AudioCodecSpecific;
 use mp4parse::AvifContext;
 use mp4parse::CodecType;
@@ -621,20 +622,19 @@ 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<u64> = match track
+        let media_time: CheckedInteger<_> = match track
             .media_time
-            .map_or(Some(mp4parse::unstable::Microseconds(0)), |media_time| {
-                mp4parse::unstable::track_time_to_us(media_time, track_timescale)
+            .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<u64> = match track.empty_duration.map_or(
-            Some(mp4parse::unstable::Microseconds(0)),
-            |empty_duration| {
-                mp4parse::unstable::media_time_to_us(empty_duration, context_timescale)
-            },
-        ) {
+        let empty_duration: CheckedInteger<_> = match 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,
         };
@@ -644,7 +644,7 @@ pub unsafe extern "C" fn mp4parse_get_track_info(
         };
 
         if let Some(track_duration) = track.duration {
-            match mp4parse::unstable::track_time_to_us(track_duration, track_timescale) {
+            match track_time_to_us(track_duration, track_timescale) {
                 Some(duration) => info.duration = duration.0,
                 None => return Mp4parseStatus::Invalid,
             }
@@ -1114,15 +1114,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)
+        (&Some(t), &Some(s)) => track_time_to_us(t, s)
             .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)
+            (&Some(e), &Some(s)) => media_time_to_us(e, s)
                 .and_then(|v| i64::try_from(v.0).ok())
                 .map(Into::into),
             _ => None,
@@ -1138,7 +1138,7 @@ fn get_indice_table(
         _ => 0.into(),
     };
 
-    if let Some(v) = mp4parse::unstable::create_sample_table(track, offset_time) {
+    if let Some(v) = create_sample_table(track, offset_time) {
         indices.set_indices(&v);
         index_table.insert(track_id, v)?;
         return Ok(());
@@ -1179,7 +1179,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) {
+        info.fragment_duration = match media_time_to_us(time, scale) {
             Some(time_us) => time_us.0 as u64,
             None => return Mp4parseStatus::Invalid,
         }