Use new format constructors

See https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1128

20 files changed, 164 insertions, 298 deletions

diff --git a/video/cdg/src/cdgparse/imp.rs b/video/cdg/src/cdgparse/imp.rs
index 12ea25524..4cf32b5f9 100644
--- a/video/cdg/src/cdgparse/imp.rs
+++ b/video/cdg/src/cdgparse/imp.rs
@@ -92,22 +92,20 @@ impl ElementImpl for CdgParse {
 }
 
 fn bytes_to_time(bytes: Bytes) -> gst::ClockTime {
-    let nb = *bytes / CDG_PACKET_SIZE as u64;
-    gst::ClockTime::from_nseconds(
-        nb.mul_div_round(*gst::ClockTime::SECOND, CDG_PACKET_PERIOD)
-            .unwrap(),
-    )
+    let nb = bytes / CDG_PACKET_SIZE as u64;
+    nb.mul_div_round(*gst::ClockTime::SECOND, CDG_PACKET_PERIOD)
+        .unwrap()
+        .nseconds()
 }
 
 fn time_to_bytes(time: gst::ClockTime) -> Bytes {
-    Bytes::from_u64(
-        time.nseconds()
-            .mul_div_round(
-                CDG_PACKET_PERIOD * CDG_PACKET_SIZE as u64,
-                *gst::ClockTime::SECOND,
-            )
-            .unwrap(),
-    )
+    time.nseconds()
+        .mul_div_round(
+            CDG_PACKET_PERIOD * CDG_PACKET_SIZE as u64,
+            *gst::ClockTime::SECOND,
+        )
+        .unwrap()
+        .bytes()
 }
 
 impl BaseParseImpl for CdgParse {
@@ -191,7 +189,7 @@ impl BaseParseImpl for CdgParse {
             }
         };
 
-        let pts = bytes_to_time(Bytes::from_u64(frame.offset()));
+        let pts = bytes_to_time(frame.offset().bytes());
         let buffer = frame.buffer_mut().unwrap();
         buffer.set_pts(pts);
 
diff --git a/video/closedcaption/src/ccdetect/imp.rs b/video/closedcaption/src/ccdetect/imp.rs
index b6691dd4b..d8fcf5b32 100644
--- a/video/closedcaption/src/ccdetect/imp.rs
+++ b/video/closedcaption/src/ccdetect/imp.rs
@@ -258,8 +258,7 @@ impl ObjectImpl for CCDetect {
         match pspec.name() {
             "window" => {
                 let mut settings = self.settings.lock().unwrap();
-                settings.window =
-                    gst::ClockTime::from_nseconds(value.get().expect("type checked upstream"));
+                settings.window = value.get::<u64>().unwrap().nseconds();
             }
             _ => unimplemented!(),
         }
diff --git a/video/closedcaption/src/cea608overlay/imp.rs b/video/closedcaption/src/cea608overlay/imp.rs
index b4b56cc8b..dccaf568c 100644
--- a/video/closedcaption/src/cea608overlay/imp.rs
+++ b/video/closedcaption/src/cea608overlay/imp.rs
@@ -577,7 +577,7 @@ impl ObjectImpl for Cea608Overlay {
                 glib::ParamSpecUInt64::builder("timeout")
                     .nick("Timeout")
                     .blurb("Duration after which to erase overlay when no cc data has arrived for the selected field")
-                    .minimum(gst::ClockTime::from_seconds(16).nseconds())
+                    .minimum(16.seconds().nseconds())
                     .default_value(u64::MAX)
                     .mutable_playing()
                     .build(),
@@ -613,7 +613,7 @@ impl ObjectImpl for Cea608Overlay {
 
                 settings.timeout = match timeout {
                     u64::MAX => gst::ClockTime::NONE,
-                    _ => Some(gst::ClockTime::from_nseconds(timeout)),
+                    _ => Some(timeout.nseconds()),
                 };
             }
             _ => unimplemented!(),
diff --git a/video/closedcaption/src/jsontovtt/imp.rs b/video/closedcaption/src/jsontovtt/imp.rs
index 842a055d6..3f28c416d 100644
--- a/video/closedcaption/src/jsontovtt/imp.rs
+++ b/video/closedcaption/src/jsontovtt/imp.rs
@@ -582,7 +582,7 @@ impl ObjectImpl for JsonToVtt {
             vec![glib::ParamSpecUInt64::builder("timeout")
                 .nick("Timeout")
                 .blurb("Duration after which to erase text when no data has arrived")
-                .minimum(gst::ClockTime::from_seconds(16).nseconds())
+                .minimum(16.seconds().nseconds())
                 .default_value(u64::MAX)
                 .mutable_playing()
                 .build()]
@@ -601,7 +601,7 @@ impl ObjectImpl for JsonToVtt {
 
                 settings.timeout = match timeout {
                     u64::MAX => gst::ClockTime::NONE,
-                    _ => Some(gst::ClockTime::from_nseconds(timeout)),
+                    _ => Some(timeout.nseconds()),
                 };
                 state.settings.timeout = settings.timeout;
             }
@@ -707,15 +707,12 @@ mod tests {
 
         let segment = gst::FormattedSegment::<gst::ClockTime>::new();
 
-        let pts: gst::ClockTime = gst::ClockTime::from_nseconds(0);
-        let duration: Option<gst::ClockTime> = Some(gst::ClockTime::from_nseconds(10));
+        let pts = gst::ClockTime::ZERO;
+        let duration = Some(10.nseconds());
 
         assert_eq!(
             clamp(&segment, pts, duration),
-            Some((
-                gst::ClockTime::from_nseconds(0),
-                Some(gst::ClockTime::from_nseconds(10))
-            ))
+            Some((gst::ClockTime::ZERO, Some(10.nseconds())))
         );
     }
 
@@ -724,17 +721,14 @@ mod tests {
         gst::init().unwrap();
 
         let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
-        segment.set_start(gst::ClockTime::from_nseconds(2));
+        segment.set_start(2.nseconds());
 
-        let pts = gst::ClockTime::from_nseconds(0);
-        let duration = Some(gst::ClockTime::from_nseconds(10));
+        let pts = gst::ClockTime::ZERO;
+        let duration = Some(10.nseconds());
 
         assert_eq!(
             clamp(&segment, pts, duration),
-            Some((
-                gst::ClockTime::from_nseconds(2),
-                Some(gst::ClockTime::from_nseconds(8))
-            ))
+            Some((2.nseconds(), Some(8.nseconds())))
         );
     }
 
@@ -743,17 +737,14 @@ mod tests {
         gst::init().unwrap();
 
         let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
-        segment.set_stop(gst::ClockTime::from_nseconds(7));
+        segment.set_stop(7.nseconds());
 
-        let pts = gst::ClockTime::from_nseconds(0);
-        let duration = Some(gst::ClockTime::from_nseconds(10));
+        let pts = gst::ClockTime::ZERO;
+        let duration = Some(10.nseconds());
 
         assert_eq!(
             clamp(&segment, pts, duration),
-            Some((
-                gst::ClockTime::from_nseconds(0),
-                Some(gst::ClockTime::from_nseconds(7))
-            ))
+            Some((gst::ClockTime::ZERO, Some(7.nseconds())))
         );
     }
 
@@ -762,18 +753,15 @@ mod tests {
         gst::init().unwrap();
 
         let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
-        segment.set_start(gst::ClockTime::from_nseconds(2));
-        segment.set_stop(gst::ClockTime::from_nseconds(7));
+        segment.set_start(2.nseconds());
+        segment.set_stop(7.nseconds());
 
-        let pts = gst::ClockTime::from_nseconds(0);
-        let duration = Some(gst::ClockTime::from_nseconds(10));
+        let pts = gst::ClockTime::ZERO;
+        let duration = Some(10.nseconds());
 
         assert_eq!(
             clamp(&segment, pts, duration),
-            Some((
-                gst::ClockTime::from_nseconds(2),
-                Some(gst::ClockTime::from_nseconds(5))
-            ))
+            Some((2.nseconds(), Some(5.nseconds())))
         );
     }
 
@@ -782,10 +770,10 @@ mod tests {
         gst::init().unwrap();
 
         let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
-        segment.set_start(gst::ClockTime::from_nseconds(15));
+        segment.set_start(15.nseconds());
 
-        let pts = gst::ClockTime::from_nseconds(0);
-        let duration = Some(gst::ClockTime::from_nseconds(10));
+        let pts = gst::ClockTime::ZERO;
+        let duration = Some(10.nseconds());
 
         assert_eq!(clamp(&segment, pts, duration), None);
     }
@@ -795,10 +783,10 @@ mod tests {
         gst::init().unwrap();
 
         let mut segment = gst::FormattedSegment::<gst::ClockTime>::new();
-        segment.set_stop(gst::ClockTime::from_nseconds(10));
+        segment.set_stop(10.nseconds());
 
-        let pts = gst::ClockTime::from_nseconds(15);
-        let duration = Some(gst::ClockTime::from_nseconds(10));
+        let pts = 15.nseconds();
+        let duration = Some(10.nseconds());
 
         assert_eq!(clamp(&segment, pts, duration), None);
     }
diff --git a/video/closedcaption/src/transcriberbin/imp.rs b/video/closedcaption/src/transcriberbin/imp.rs
index 07710c96a..251cc278c 100644
--- a/video/closedcaption/src/transcriberbin/imp.rs
+++ b/video/closedcaption/src/transcriberbin/imp.rs
@@ -220,9 +220,7 @@ impl TranscriberBin {
 
         self.instance().add(&state.internal_bin)?;
 
-        state
-            .cccombiner
-            .set_property("latency", 100 * gst::ClockTime::MSECOND);
+        state.cccombiner.set_property("latency", 100.mseconds());
 
         self.audio_sinkpad
             .set_target(Some(&state.internal_bin.static_pad("audio_sink").unwrap()))?;
diff --git a/video/closedcaption/src/tttocea608/imp.rs b/video/closedcaption/src/tttocea608/imp.rs
index c1b6d90fb..ee89f42a6 100644
--- a/video/closedcaption/src/tttocea608/imp.rs
+++ b/video/closedcaption/src/tttocea608/imp.rs
@@ -204,7 +204,9 @@ impl State {
 
         let (fps_n, fps_d) = (self.framerate.numer() as u64, self.framerate.denom() as u64);
 
-        let pts = (self.last_frame_no * gst::ClockTime::SECOND)
+        let pts = self
+            .last_frame_no
+            .seconds()
             .mul_div_round(fps_d, fps_n)
             .unwrap();
 
@@ -214,7 +216,9 @@ impl State {
             gst::debug!(CAT, imp: imp, "More text than bandwidth!");
         }
 
-        let next_pts = (self.last_frame_no * gst::ClockTime::SECOND)
+        let next_pts = self
+            .last_frame_no
+            .seconds()
             .mul_div_round(fps_d, fps_n)
             .unwrap();
 
@@ -1065,7 +1069,7 @@ impl ObjectImpl for TtToCea608 {
 
                 settings.roll_up_timeout = match timeout {
                     u64::MAX => gst::ClockTime::NONE,
-                    _ => Some(gst::ClockTime::from_nseconds(timeout)),
+                    _ => Some(timeout.nseconds()),
                 };
             }
             _ => unimplemented!(),
diff --git a/video/closedcaption/tests/ccdetect.rs b/video/closedcaption/tests/ccdetect.rs
index 57069273f..5d8c9444a 100644
--- a/video/closedcaption/tests/ccdetect.rs
+++ b/video/closedcaption/tests/ccdetect.rs
@@ -78,34 +78,13 @@ fn test_have_cc_data_notify() {
     assert_push_data!(h, state, valid_cc608_data, ClockTime::ZERO, 1, 0);
 
     /* invalid cc608 data moves cc608 property to false */
-    assert_push_data!(
-        h,
-        state,
-        invalid_cc608_data,
-        ClockTime::from_nseconds(1_000_000_000),
-        2,
-        0
-    );
+    assert_push_data!(h, state, invalid_cc608_data, 1_000_000_000.nseconds(), 2, 0);
 
     /* valid cc708 data moves cc708 property to true */
-    assert_push_data!(
-        h,
-        state,
-        valid_cc708_data,
-        ClockTime::from_nseconds(2_000_000_000),
-        2,
-        1
-    );
+    assert_push_data!(h, state, valid_cc708_data, 2_000_000_000.nseconds(), 2, 1);
 
     /* invalid cc708 data moves cc708 property to false */
-    assert_push_data!(
-        h,
-        state,
-        invalid_cc708_data,
-        ClockTime::from_nseconds(3_000_000_000),
-        2,
-        2
-    );
+    assert_push_data!(h, state, invalid_cc708_data, 3_000_000_000.nseconds(), 2, 2);
 }
 
 #[test]
@@ -143,7 +122,7 @@ fn test_cc_data_window() {
         h,
         state,
         valid_cc608_data.clone(),
-        ClockTime::from_nseconds(300_000_000),
+        300_000_000.nseconds(),
         1,
         0
     );
@@ -153,40 +132,26 @@ fn test_cc_data_window() {
         h,
         state,
         invalid_cc608_data.clone(),
-        ClockTime::from_nseconds(600_000_000),
+        600_000_000.nseconds(),
         1,
         0
     );
 
     /* invalid cc608 data after window expires, cc608 changes to false */
-    assert_push_data!(
-        h,
-        state,
-        invalid_cc608_data,
-        ClockTime::from_nseconds(1_000_000_000),
-        2,
-        0
-    );
+    assert_push_data!(h, state, invalid_cc608_data, 1_000_000_000.nseconds(), 2, 0);
 
     /* valid cc608 data before window expires, no change */
     assert_push_data!(
         h,
         state,
         valid_cc608_data.clone(),
-        ClockTime::from_nseconds(1_300_000_000),
+        1_300_000_000.nseconds(),
         2,
         0
     );
 
     /* valid cc608 data after window expires, property changes */
-    assert_push_data!(
-        h,
-        state,
-        valid_cc608_data,
-        ClockTime::from_nseconds(1_600_000_000),
-        3,
-        0
-    );
+    assert_push_data!(h, state, valid_cc608_data, 1_600_000_000.nseconds(), 3, 0);
 }
 
 #[test]
@@ -235,14 +200,7 @@ fn test_have_cdp_notify() {
     assert_push_data!(h, state, valid_cc608_data, ClockTime::ZERO, 1, 0);
 
     /* invalid cc608 data moves cc608 property to false */
-    assert_push_data!(
-        h,
-        state,
-        invalid_cc608_data,
-        ClockTime::from_nseconds(1_000_000_000),
-        2,
-        0
-    );
+    assert_push_data!(h, state, invalid_cc608_data, 1_000_000_000.nseconds(), 2, 0);
 }
 
 #[test]
@@ -300,56 +258,21 @@ fn test_malformed_cdp_notify() {
         });
 
     /* all invalid data does not change properties */
-    assert_push_data!(h, state, too_short, ClockTime::from_nseconds(0), 0, 0);
-    assert_push_data!(h, state, wrong_magic, ClockTime::from_nseconds(1_000), 0, 0);
-    assert_push_data!(
-        h,
-        state,
-        length_too_long,
-        ClockTime::from_nseconds(2_000),
-        0,
-        0
-    );
-    assert_push_data!(
-        h,
-        state,
-        length_too_short,
-        ClockTime::from_nseconds(3_000),
-        0,
-        0
-    );
-    assert_push_data!(
-        h,
-        state,
-        wrong_cc_data_header_byte,
-        ClockTime::from_nseconds(4_000),
-        0,
-        0
-    );
-    assert_push_data!(
-        h,
-        state,
-        big_cc_count,
-        ClockTime::from_nseconds(5_000),
-        0,
-        0
-    );
+    assert_push_data!(h, state, too_short, ClockTime::ZERO, 0, 0);
+    assert_push_data!(h, state, wrong_magic, 1_000.nseconds(), 0, 0);
+    assert_push_data!(h, state, length_too_long, 2_000.nseconds(), 0, 0);
+    assert_push_data!(h, state, length_too_short, 3_000.nseconds(), 0, 0);
+    assert_push_data!(h, state, wrong_cc_data_header_byte, 4_000.nseconds(), 0, 0);
+    assert_push_data!(h, state, big_cc_count, 5_000.nseconds(), 0, 0);
     assert_push_data!(
         h,
         state,
         wrong_cc_count_reserved_bits,
-        ClockTime::from_nseconds(6_000),
-        0,
-        0
-    );
-    assert_push_data!(
-        h,
-        state,
-        cc608_after_cc708,
-        ClockTime::from_nseconds(7_000),
+        6_000.nseconds(),
         0,
         0
     );
+    assert_push_data!(h, state, cc608_after_cc708, 7_000.nseconds(), 0, 0);
 }
 
 #[test]
@@ -382,10 +305,7 @@ fn test_gap_events() {
     assert_push_data!(h, state, valid_cc608_data, ClockTime::ZERO, 1, 0);
 
     /* pushing gap event within the window changes nothing */
-    assert!(h.push_event(gst::event::Gap::new(
-        ClockTime::from_nseconds(100_000_000),
-        ClockTime::from_nseconds(1)
-    )),);
+    assert!(h.push_event(gst::event::Gap::new(100_000_000.nseconds(), 1.nseconds())));
 
     {
         let state_guard = state.lock().unwrap();
@@ -394,10 +314,7 @@ fn test_gap_events() {
     }
 
     /* pushing gap event outside the window moves cc608 property to false */
-    assert!(h.push_event(gst::event::Gap::new(
-        ClockTime::from_nseconds(1_000_000_000),
-        ClockTime::from_nseconds(1)
-    )),);
+    assert!(h.push_event(gst::event::Gap::new(1_000_000_000.nseconds(), 1.nseconds())));
 
     {
         let state_guard = state.lock().unwrap();
diff --git a/video/closedcaption/tests/cea608tott.rs b/video/closedcaption/tests/cea608tott.rs
index b3169b8be..01db571d6 100644
--- a/video/closedcaption/tests/cea608tott.rs
+++ b/video/closedcaption/tests/cea608tott.rs
@@ -36,23 +36,23 @@ fn test_parse() {
     // Check the first 4 output buffers
     let expected: [(ClockTime, ClockTime, &'static str); 4] = [
         (
-            ClockTime::from_nseconds(15_048_366_666),
-            ClockTime::from_nseconds(3_236_566_667),
+            15_048_366_666.nseconds(),
+            3_236_566_667.nseconds(),
             "From New York,\r\nthis is Democracy Now!",
         ),
         (
-            ClockTime::from_nseconds(18_985_633_333),
-            ClockTime::from_nseconds(1_234_566_667),
+            18_985_633_333.nseconds(),
+            1_234_566_667.nseconds(),
             "Yes, I’m supporting\r\nDonald Trump.",
         ),
         (
-            ClockTime::from_nseconds(20_220_200_000),
-            ClockTime::from_nseconds(2_168_833_333),
+            20_220_200_000.nseconds(),
+            2_168_833_333.nseconds(),
             "I’m doing so as enthusiastically\r\nas I can,",
         ),
         (
-            ClockTime::from_nseconds(22_389_033_333),
-            ClockTime::from_nseconds(2_235_566_667),
+            22_389_033_333.nseconds(),
+            2_235_566_667.nseconds(),
             "even the fact I think\r\nhe’s a terrible human being.",
         ),
     ];
diff --git a/video/closedcaption/tests/mcc_enc.rs b/video/closedcaption/tests/mcc_enc.rs
index a35a50f2f..c00f053bb 100644
--- a/video/closedcaption/tests/mcc_enc.rs
+++ b/video/closedcaption/tests/mcc_enc.rs
@@ -111,7 +111,7 @@ Time Code Rate=30DF\r\n\
         let mut buf = gst::Buffer::from_mut_slice(Vec::from(input));
         let buf_ref = buf.get_mut().unwrap();
         gst_video::VideoTimeCodeMeta::add(buf_ref, &tc);
-        buf_ref.set_pts(gst::ClockTime::from_seconds(0));
+        buf_ref.set_pts(gst::ClockTime::ZERO);
         buf
     };
 
diff --git a/video/closedcaption/tests/mcc_parse.rs b/video/closedcaption/tests/mcc_parse.rs
index 4ea009743..8c67fae87 100644
--- a/video/closedcaption/tests/mcc_parse.rs
+++ b/video/closedcaption/tests/mcc_parse.rs
@@ -170,7 +170,7 @@ fn test_pull() {
         gst::SeekType::Set,
         gst::ClockTime::SECOND,
         gst::SeekType::Set,
-        2 * gst::ClockTime::SECOND,
+        2.seconds(),
     ));
 
     loop {
@@ -179,7 +179,7 @@ fn test_pull() {
         while h.buffers_in_queue() != 0 {
             if let Ok(buffer) = h.pull() {
                 let pts = buffer.pts().unwrap();
-                assert!(pts > gst::ClockTime::SECOND && pts < 2 * gst::ClockTime::SECOND);
+                assert!(pts > gst::ClockTime::SECOND && pts < 2.seconds());
             }
         }
 
diff --git a/video/closedcaption/tests/scc_enc.rs b/video/closedcaption/tests/scc_enc.rs
index 33a068e41..b23e9d70a 100644
--- a/video/closedcaption/tests/scc_enc.rs
+++ b/video/closedcaption/tests/scc_enc.rs
@@ -45,7 +45,7 @@ fn test_encode_single_packet() {
         let mut buf = gst::Buffer::from_mut_slice(Vec::from(&input[..]));
         let buf_ref = buf.get_mut().unwrap();
         gst_video::VideoTimeCodeMeta::add(buf_ref, &tc);
-        buf_ref.set_pts(gst::ClockTime::from_seconds(0));
+        buf_ref.set_pts(gst::ClockTime::ZERO);
         buf
     };
 
@@ -117,7 +117,7 @@ fn test_encode_multiple_packets() {
         let mut buf = gst::Buffer::from_mut_slice(Vec::from(&input1[..]));
         let buf_ref = buf.get_mut().unwrap();
         gst_video::VideoTimeCodeMeta::add(buf_ref, &tc1);
-        buf_ref.set_pts(gst::ClockTime::from_seconds(0));
+        buf_ref.set_pts(gst::ClockTime::ZERO);
         buf
     };
 
@@ -127,7 +127,7 @@ fn test_encode_multiple_packets() {
         let mut tc = tc1.clone();
         tc.increment_frame();
         gst_video::VideoTimeCodeMeta::add(buf_ref, &tc);
-        buf_ref.set_pts(gst::ClockTime::from_seconds(0));
+        buf_ref.set_pts(gst::ClockTime::ZERO);
         buf
     };
 
diff --git a/video/closedcaption/tests/scc_parse.rs b/video/closedcaption/tests/scc_parse.rs
index 63b04ca5f..542ed711f 100644
--- a/video/closedcaption/tests/scc_parse.rs
+++ b/video/closedcaption/tests/scc_parse.rs
@@ -235,9 +235,9 @@ fn test_pull() {
         1.0,
         gst::SeekFlags::FLUSH,
         gst::SeekType::Set,
-        18 * gst::ClockTime::SECOND,
+        18.seconds(),
         gst::SeekType::Set,
-        19 * gst::ClockTime::SECOND,
+        19.seconds(),
     ));
 
     loop {
@@ -248,9 +248,7 @@ fn test_pull() {
                 let pts = buffer.pts().unwrap();
                 let end_time = pts + buffer.duration().unwrap();
 
-                assert!(
-                    end_time >= 18 * gst::ClockTime::SECOND && pts < 19 * gst::ClockTime::SECOND
-                );
+                assert!(end_time >= 18.seconds() && pts < 19.seconds());
             }
         }
 
diff --git a/video/closedcaption/tests/tttocea608.rs b/video/closedcaption/tests/tttocea608.rs
index 17b5d3843..89ccff616 100644
--- a/video/closedcaption/tests/tttocea608.rs
+++ b/video/closedcaption/tests/tttocea608.rs
@@ -6,6 +6,7 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+use gst::prelude::*;
 use gst::ClockTime;
 use pretty_assertions::assert_eq;
 
@@ -61,38 +62,38 @@ fn test_one_timed_buffer_and_eos() {
 
     let expected: [(ClockTime, ClockTime, [u8; 2usize]); 7] = [
         (
-            ClockTime::from_nseconds(1_000_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_000_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x20],
         ), /* resume_caption_loading */
         (
-            ClockTime::from_nseconds(1_033_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_033_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0x94, 0xae],
         ), /* erase_non_displayed_memory */
         (
-            ClockTime::from_nseconds(1_066_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_066_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x70],
         ), /* preamble */
         (
-            ClockTime::from_nseconds(1_100_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_100_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0xc8, 0xe5],
         ), /* H e */
         (
-            ClockTime::from_nseconds(1_133_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_133_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0xec, 0xec],
         ), /* l l */
         (
-            ClockTime::from_nseconds(1_166_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_166_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0xef, 0x80],
         ), /* o, nil */
         (
-            ClockTime::from_nseconds(1_200_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_200_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x2f],
         ), /* end_of_caption */
     ];
@@ -125,7 +126,7 @@ fn test_one_timed_buffer_and_eos() {
     loop {
         let outbuf = h.try_pull().unwrap();
         let data = outbuf.map_readable().unwrap();
-        if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
+        if outbuf.pts().unwrap() == 2_200_000_000.nseconds() {
             assert_eq!(&*data, &[0x94, 0x2c]);
             break;
         } else {
@@ -154,18 +155,10 @@ fn test_erase_display_memory_non_spliced() {
         let _event = h.pull_event().unwrap();
     }
 
-    let inbuf = new_timed_buffer(
-        &"Hello",
-        ClockTime::from_nseconds(1_000_000_000),
-        ClockTime::SECOND,
-    );
+    let inbuf = new_timed_buffer(&"Hello", 1_000_000_000.nseconds(), ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
-    let inbuf = new_timed_buffer(
-        &"World",
-        ClockTime::from_nseconds(3_000_000_000),
-        ClockTime::SECOND,
-    );
+    let inbuf = new_timed_buffer(&"World", 3_000_000_000.nseconds(), ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
     let mut erase_display_buffers = 0;
@@ -173,7 +166,7 @@ fn test_erase_display_memory_non_spliced() {
     while h.buffers_in_queue() > 0 {
         let outbuf = h.pull().unwrap();
 
-        if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
+        if outbuf.pts().unwrap() == 2_200_000_000.nseconds() {
             let data = outbuf.map_readable().unwrap();
             assert_eq!(&*data, &[0x94, 0x2c]);
             erase_display_buffers += 1;
@@ -204,16 +197,12 @@ fn test_erase_display_memory_spliced() {
         let _event = h.pull_event().unwrap();
     }
 
-    let inbuf = new_timed_buffer(
-        &"Hello",
-        ClockTime::from_nseconds(1_000_000_000),
-        ClockTime::SECOND,
-    );
+    let inbuf = new_timed_buffer(&"Hello", 1_000_000_000.nseconds(), ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
     let inbuf = new_timed_buffer(
         &"World, Lorem Ipsum",
-        ClockTime::from_nseconds(2_000_000_000),
+        2_000_000_000.nseconds(),
         ClockTime::SECOND,
     );
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
@@ -228,7 +217,7 @@ fn test_erase_display_memory_spliced() {
         let pts = outbuf.pts().unwrap();
         assert!(pts >= prev_pts);
 
-        if pts == ClockTime::from_nseconds(2_200_000_000) {
+        if pts == 2_200_000_000.nseconds() {
             let data = outbuf.map_readable().unwrap();
             assert_eq!(&*data, &[0x94, 0x2c]);
             erase_display_buffers += 1;
@@ -254,18 +243,10 @@ fn test_output_gaps() {
         let _event = h.pull_event().unwrap();
     }
 
-    let inbuf = new_timed_buffer(
-        &"Hello",
-        ClockTime::from_nseconds(1_000_000_000),
-        ClockTime::SECOND,
-    );
+    let inbuf = new_timed_buffer(&"Hello", 1_000_000_000.nseconds(), ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
-    let inbuf = new_timed_buffer(
-        &"World",
-        ClockTime::from_nseconds(3_000_000_000),
-        ClockTime::SECOND,
-    );
+    let inbuf = new_timed_buffer(&"World", 3_000_000_000.nseconds(), ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
     h.push_event(gst::event::Eos::new());
@@ -284,9 +265,7 @@ fn test_output_gaps() {
     /* Hello */
     loop {
         let outbuf = h.pull().unwrap();
-        if outbuf.pts().unwrap() + outbuf.duration().unwrap()
-            >= ClockTime::from_nseconds(1_233_333_333)
-        {
+        if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 1_233_333_333.nseconds() {
             break;
         }
 
@@ -297,14 +276,12 @@ fn test_output_gaps() {
     /* Padding */
     loop {
         let outbuf = h.pull().unwrap();
-        if outbuf.pts().unwrap() + outbuf.duration().unwrap()
-            >= ClockTime::from_nseconds(3_000_000_000)
-        {
+        if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 3_000_000_000.nseconds() {
             break;
         }
 
         let data = outbuf.map_readable().unwrap();
-        if outbuf.pts().unwrap() == ClockTime::from_nseconds(2_200_000_000) {
+        if outbuf.pts().unwrap() == 2_200_000_000.nseconds() {
             /* Erase display one second after Hello */
             assert_eq!(&*data, &[0x94, 0x2C]);
         } else {
@@ -315,9 +292,7 @@ fn test_output_gaps() {
     /* World */
     loop {
         let outbuf = h.pull().unwrap();
-        if outbuf.pts().unwrap() + outbuf.duration().unwrap()
-            >= ClockTime::from_nseconds(3_233_333_333)
-        {
+        if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 3_233_333_333.nseconds() {
             break;
         }
 
@@ -345,33 +320,33 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
     let inbuf = new_timed_buffer(&"Hello", ClockTime::SECOND, ClockTime::SECOND);
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
-    let inbuf = new_timed_buffer(&"World", 2 * ClockTime::SECOND, ClockTime::from_nseconds(1));
+    let inbuf = new_timed_buffer(&"World", 2.seconds(), 1.nseconds());
     assert_eq!(h.push(inbuf), Ok(gst::FlowSuccess::Ok));
 
     let expected: [(ClockTime, ClockTime, [u8; 2usize]); 5] = [
         (
-            ClockTime::from_nseconds(1_000_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_000_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x25],
         ), /* roll_up_2 */
         (
-            ClockTime::from_nseconds(1_033_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_033_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0x94, 0x70],
         ), /* preamble */
         (
-            ClockTime::from_nseconds(1_066_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_066_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0xc8, 0xe5],
         ), /* H e */
         (
-            ClockTime::from_nseconds(1_100_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_100_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0xec, 0xec],
         ), /* l l */
         (
-            ClockTime::from_nseconds(1_133_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_133_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0xef, 0x80],
         ), /* o nil */
     ];
@@ -399,7 +374,7 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
     /* Padding */
     loop {
         let outbuf = h.pull().unwrap();
-        if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 2 * ClockTime::SECOND {
+        if outbuf.pts().unwrap() + outbuf.duration().unwrap() >= 2.seconds() {
             break;
         }
 
@@ -408,21 +383,9 @@ fn test_one_timed_buffer_and_eos_roll_up2() {
     }
 
     let expected: [(ClockTime, ClockTime, [u8; 2usize]); 3] = [
-        (
-            ClockTime::from_nseconds(2_000_000_000),
-            ClockTime::ZERO,
-            [0x20, 0x57],
-        ), /* SPACE W */
-        (
-            ClockTime::from_nseconds(2_000_000_000),
-            ClockTime::ZERO,
-            [0xef, 0xf2],
-        ), /* o r */
-        (
-            ClockTime::from_nseconds(2_000_000_000),
-            ClockTime::ZERO,
-            [0xec, 0x64],
-        ), /* l d */
+        (2_000_000_000.nseconds(), ClockTime::ZERO, [0x20, 0x57]), /* SPACE W */
+        (2_000_000_000.nseconds(), ClockTime::ZERO, [0xef, 0xf2]), /* o r */
+        (2_000_000_000.nseconds(), ClockTime::ZERO, [0xec, 0x64]), /* l d */
     ];
 
     for (i, e) in expected.iter().enumerate() {
@@ -475,58 +438,58 @@ fn test_word_wrap_roll_up() {
 
     let expected: [(ClockTime, ClockTime, [u8; 2usize]); 11] = [
         (
-            ClockTime::from_nseconds(1_000_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_000_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x25],
         ), /* roll_up_2 */
         (
-            ClockTime::from_nseconds(1_033_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_033_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0x94, 0x7c],
         ), /* preamble */
         (
-            ClockTime::from_nseconds(1_066_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_066_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0xc8, 0xe5],
         ), /* H e */
         (
-            ClockTime::from_nseconds(1_100_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_100_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0xec, 0xec],
         ), /* l l */
         (
-            ClockTime::from_nseconds(1_133_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_133_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0xef, 0x20],
         ), /* o SPACE */
         (
-            ClockTime::from_nseconds(1_166_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_166_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0xad],
         ), /* carriage return */
         (
-            ClockTime::from_nseconds(1_200_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_200_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0x94, 0x25],
         ), /* roll_up_2 */
         (
-            ClockTime::from_nseconds(1_233_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_233_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0x94, 0x7c],
         ), /* preamble */
         (
-            ClockTime::from_nseconds(1_266_666_667),
-            ClockTime::from_nseconds(33_333_333),
+            1_266_666_667.nseconds(),
+            33_333_333.nseconds(),
             [0x57, 0xef],
         ), /* W o */
         (
-            ClockTime::from_nseconds(1_300_000_000),
-            ClockTime::from_nseconds(33_333_333),
+            1_300_000_000.nseconds(),
+            33_333_333.nseconds(),
             [0xf2, 0xec],
         ), /* r l */
         (
-            ClockTime::from_nseconds(1_333_333_333),
-            ClockTime::from_nseconds(33_333_334),
+            1_333_333_333.nseconds(),
+            33_333_334.nseconds(),
             [0x64, 0x80],
         ), /* d nil */
     ];
diff --git a/video/dav1d/src/dav1ddec/imp.rs b/video/dav1d/src/dav1ddec/imp.rs
index 211158687..1fa7ea8a3 100644
--- a/video/dav1d/src/dav1ddec/imp.rs
+++ b/video/dav1d/src/dav1ddec/imp.rs
@@ -344,7 +344,7 @@ impl Dav1dDec {
             out_buffer
                 .get_mut()
                 .unwrap()
-                .set_duration(gst::ClockTime::from_nseconds(duration));
+                .set_duration(duration.nseconds());
         }
 
         Ok(out_buffer)
@@ -614,9 +614,7 @@ impl VideoDecoderImpl for Dav1dDec {
                                     n => n,
                                 };
 
-                                let latency = frame_latency
-                                    * (info.fps().denom() as u64)
-                                    * gst::ClockTime::SECOND
+                                let latency = frame_latency * (info.fps().denom() as u64).seconds()
                                     / (fps_n as u64);
 
                                 gst::debug!(CAT, imp: self, "Reporting latency of {}", latency);
diff --git a/video/flavors/src/flvdemux/imp.rs b/video/flavors/src/flvdemux/imp.rs
index 7905a9695..67d2f7d9d 100644
--- a/video/flavors/src/flvdemux/imp.rs
+++ b/video/flavors/src/flvdemux/imp.rs
@@ -936,7 +936,7 @@ impl StreamingState {
 
         {
             let buffer = buffer.get_mut().unwrap();
-            buffer.set_pts(gst::ClockTime::from_mseconds(tag_header.timestamp as u64));
+            buffer.set_pts((tag_header.timestamp as u64).mseconds());
         }
 
         gst::trace!(
@@ -1130,7 +1130,7 @@ impl StreamingState {
             if !is_keyframe {
                 buffer.set_flags(gst::BufferFlags::DELTA_UNIT);
             }
-            buffer.set_dts(gst::ClockTime::from_mseconds(tag_header.timestamp as u64));
+            buffer.set_dts((tag_header.timestamp as u64).mseconds());
 
             // Prevent negative numbers
             let pts = if cts < 0 && tag_header.timestamp < (-cts) as u32 {
@@ -1138,7 +1138,7 @@ impl StreamingState {
             } else {
                 ((tag_header.timestamp as i64) + (cts as i64)) as u64
             };
-            buffer.set_pts(gst::ClockTime::from_mseconds(pts));
+            buffer.set_pts(pts.mseconds());
         }
 
         gst::trace!(
@@ -1487,9 +1487,8 @@ impl Metadata {
         for arg in args {
             match (arg.name, &arg.data) {
                 ("duration", &flavors::ScriptDataValue::Number(duration)) => {
-                    metadata.duration = Some(gst::ClockTime::from_nseconds(
-                        (duration * 1000.0 * 1000.0 * 1000.0) as u64,
-                    ));
+                    metadata.duration =
+                        Some(((duration * 1000.0 * 1000.0 * 1000.0) as u64).nseconds());
                 }
                 ("creationdate", &flavors::ScriptDataValue::String(date)) => {
                     metadata.creation_date = Some(String::from(date));
diff --git a/video/gif/src/gifenc/imp.rs b/video/gif/src/gifenc/imp.rs
index 64435a50b..043fa1147 100644
--- a/video/gif/src/gifenc/imp.rs
+++ b/video/gif/src/gifenc/imp.rs
@@ -375,7 +375,7 @@ impl VideoEncoderImpl for GifEnc {
             gif_frame.delay = (frame_delay.mseconds() as f32 / 10.0).round() as u16;
             state.gif_pts = state
                 .gif_pts
-                .opt_add(gst::ClockTime::from_mseconds(gif_frame.delay as u64 * 10));
+                .opt_add((gif_frame.delay as u64 * 10).mseconds());
 
             // encode new frame
             let context = state.context.as_mut().unwrap();
diff --git a/video/gif/tests/gifenc.rs b/video/gif/tests/gifenc.rs
index 8d9ce9a67..fd928e6d4 100644
--- a/video/gif/tests/gifenc.rs
+++ b/video/gif/tests/gifenc.rs
@@ -8,6 +8,8 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use gst::prelude::*;
+
 fn init() {
     use std::sync::Once;
     static INIT: Once = Once::new();
@@ -48,7 +50,7 @@ fn test_encode(video_info: &gst_video::VideoInfo) {
             let mut buffer = gst::Buffer::with_size(video_info.size()).unwrap();
             {
                 let buffer = buffer.get_mut().unwrap();
-                buffer.set_pts(gst::ClockTime::from_seconds(pts));
+                buffer.set_pts(pts.seconds());
             }
             let mut vframe =
                 gst_video::VideoFrame::from_buffer_writable(buffer, video_info).unwrap();
diff --git a/video/rspng/tests/pngenc.rs b/video/rspng/tests/pngenc.rs
index bcac6e1f0..dabdb9793 100644
--- a/video/rspng/tests/pngenc.rs
+++ b/video/rspng/tests/pngenc.rs
@@ -8,6 +8,8 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use gst::prelude::*;
+
 fn init() {
     use std::sync::Once;
     static INIT: Once = Once::new();
@@ -72,7 +74,7 @@ fn test_png_encode(video_info: &gst_video::VideoInfo) {
             let mut buffer = gst::Buffer::with_size(video_info.size()).unwrap();
             {
                 let buffer = buffer.get_mut().unwrap();
-                buffer.set_pts(gst::ClockTime::from_seconds(pts));
+                buffer.set_pts(pts.seconds());
             }
             let mut vframe =
                 gst_video::VideoFrame::from_buffer_writable(buffer, video_info).unwrap();
diff --git a/video/webp/src/dec/imp.rs b/video/webp/src/dec/imp.rs
index 277f5692e..645f71e7f 100644
--- a/video/webp/src/dec/imp.rs
+++ b/video/webp/src/dec/imp.rs
@@ -203,7 +203,7 @@ impl WebPDec {
                 gst::error_msg!(gst::StreamError::Decode, ["Failed to get next frame"])
             })?;
 
-            let timestamp = frame.timestamp as u64 * gst::ClockTime::MSECOND;
+            let timestamp = (frame.timestamp as u64).mseconds();
             let duration =
                 prev_timestamp.and_then(|prev_timestamp| timestamp.checked_sub(prev_timestamp));
 
diff --git a/video/webp/tests/webpdec.rs b/video/webp/tests/webpdec.rs
index a7b4e2c65..95451faf9 100644
--- a/video/webp/tests/webpdec.rs
+++ b/video/webp/tests/webpdec.rs
@@ -33,7 +33,7 @@ fn test_decode() {
 
     let mut expected_timestamp: Option<gst::ClockTime> = Some(gst::ClockTime::ZERO);
     let mut count = 0;
-    let expected_duration: Option<gst::ClockTime> = Some(gst::ClockTime::from_nseconds(40_000_000));
+    let expected_duration: Option<gst::ClockTime> = Some(40_000_000.nseconds());
 
     while let Some(buf) = h.try_pull() {
         assert_eq!(buf.pts(), expected_timestamp);