[RTP] remove unnecessary async function/trait

Author: yngrtc

rtp/Cargo.toml

@@ -16,14 +16,11 @@ util = { version = "0.7.0", path = "../util", package = "webrtc-util", default-f
 bytes = "1"
 rand = "0.8.5"
 thiserror = "1.0"
-async-trait = "0.1.56"
 serde = { version = "1.0.102", features = ["derive"] }
 
 [dev-dependencies]
 chrono = "0.4.23"
 criterion = "0.4.0"
-tokio = { version = "1.19", features = ["full"] }
-tokio-test = "0.4.0" # must match the min version of the `tokio` crate above
 
 [[bench]]
 name = "packet_bench"

rtp/src/packetizer/mod.rs

@@ -5,11 +5,8 @@ use crate::error::Result;
 use crate::{extension::abs_send_time_extension::*, header::*, packet::*, sequence::*};
 use util::marshal::{Marshal, MarshalSize};
 
-use async_trait::async_trait;
 use bytes::{Bytes, BytesMut};
 use std::fmt;
-use std::future::Future;
-use std::pin::Pin;
 use std::sync::Arc;
 use std::time::SystemTime;
 
@@ -26,10 +23,9 @@ impl Clone for Box<dyn Payloader + Send + Sync> {
 }
 
 /// Packetizer packetizes a payload
-#[async_trait]
 pub trait Packetizer: fmt::Debug {
     fn enable_abs_send_time(&mut self, value: u8);
-    async fn packetize(&mut self, payload: &Bytes, samples: u32) -> Result<Vec<Packet>>;
+    fn packetize(&mut self, payload: &Bytes, samples: u32) -> Result<Vec<Packet>>;
     fn skip_samples(&mut self, skipped_samples: u32);
     fn clone_to(&self) -> Box<dyn Packetizer + Send + Sync>;
 }
@@ -57,8 +53,7 @@ pub trait Depacketizer {
 //TODO: SystemTime vs Instant?
 // non-monotonic clock vs monotonically non-decreasing clock
 /// FnTimeGen provides current SystemTime
-pub type FnTimeGen =
-    Arc<dyn (Fn() -> Pin<Box<dyn Future<Output = SystemTime> + Send + 'static>>) + Send + Sync>;
+pub type FnTimeGen = Arc<dyn (Fn() -> SystemTime) + Send + Sync>;
 
 #[derive(Clone)]
 pub(crate) struct PacketizerImpl {
@@ -107,13 +102,12 @@ pub fn new_packetizer(
     }
 }
 
-#[async_trait]
 impl Packetizer for PacketizerImpl {
     fn enable_abs_send_time(&mut self, value: u8) {
         self.abs_send_time = value
     }
 
-    async fn packetize(&mut self, payload: &Bytes, samples: u32) -> Result<Vec<Packet>> {
+    fn packetize(&mut self, payload: &Bytes, samples: u32) -> Result<Vec<Packet>> {
         let payloads = self.payloader.payload(self.mtu - 12, payload)?;
         let payloads_len = payloads.len();
         let mut packets = Vec::with_capacity(payloads_len);
@@ -138,7 +132,7 @@ impl Packetizer for PacketizerImpl {
 
         if payloads_len != 0 && self.abs_send_time != 0 {
             let st = if let Some(fn_time_gen) = &self.time_gen {
-                fn_time_gen().await
+                fn_time_gen()
             } else {
                 SystemTime::now()
             };

rtp/src/packetizer/packetizer_test.rs

@@ -5,15 +5,15 @@ use crate::error::Result;
 use chrono::prelude::*;
 use std::time::{Duration, UNIX_EPOCH};
 
-#[tokio::test]
-async fn test_packetizer() -> Result<()> {
+#[test]
+fn test_packetizer() -> Result<()> {
     let multiple_payload = Bytes::from_static(&[0; 128]);
     let g722 = Box::new(g7xx::G722Payloader {});
     let seq = Box::new(new_random_sequencer());
 
     //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
     let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);
-    let packets = packetizer.packetize(&multiple_payload, 2000).await?;
+    let packets = packetizer.packetize(&multiple_payload, 2000)?;
 
     if packets.len() != 2 {
         let mut packet_lengths = String::new();
@@ -31,22 +31,18 @@ async fn test_packetizer() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn test_packetizer_abs_send_time() -> Result<()> {
+#[test]
+fn test_packetizer_abs_send_time() -> Result<()> {
     let g722 = Box::new(g7xx::G722Payloader {});
     let sequencer = Box::new(new_fixed_sequencer(1234));
 
-    let time_gen: Option<FnTimeGen> = Some(Arc::new(
-        || -> Pin<Box<dyn Future<Output = SystemTime> + Send + 'static>> {
-            Box::pin(async move {
-                let loc = FixedOffset::west_opt(5 * 60 * 60).unwrap(); // UTC-5
-                let t = loc.with_ymd_and_hms(1985, 6, 23, 4, 0, 0).unwrap();
-                UNIX_EPOCH
-                    .checked_add(Duration::from_nanos(t.timestamp_nanos() as u64))
-                    .unwrap_or(UNIX_EPOCH)
-            })
-        },
-    ));
+    let time_gen: Option<FnTimeGen> = Some(Arc::new(|| -> SystemTime {
+        let loc = FixedOffset::west_opt(5 * 60 * 60).unwrap(); // UTC-5
+        let t = loc.with_ymd_and_hms(1985, 6, 23, 4, 0, 0).unwrap();
+        UNIX_EPOCH
+            .checked_add(Duration::from_nanos(t.timestamp_nanos() as u64))
+            .unwrap_or(UNIX_EPOCH)
+    }));
 
     //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
     let mut pktizer = PacketizerImpl {
@@ -63,7 +59,7 @@ async fn test_packetizer_abs_send_time() -> Result<()> {
     pktizer.enable_abs_send_time(1);
 
     let payload = Bytes::from_static(&[0x11, 0x12, 0x13, 0x14]);
-    let packets = pktizer.packetize(&payload, 2000).await?;
+    let packets = pktizer.packetize(&payload, 2000)?;
 
     let expected = Packet {
         header: Header {
@@ -94,17 +90,17 @@ async fn test_packetizer_abs_send_time() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn test_packetizer_timestamp_rollover_does_not_panic() -> Result<()> {
+#[test]
+fn test_packetizer_timestamp_rollover_does_not_panic() -> Result<()> {
     let g722 = Box::new(g7xx::G722Payloader {});
     let seq = Box::new(new_random_sequencer());
 
     let payload = Bytes::from_static(&[0; 128]);
     let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);
 
-    packetizer.packetize(&payload, 10).await?;
+    packetizer.packetize(&payload, 10)?;
 
-    packetizer.packetize(&payload, u32::MAX).await?;
+    packetizer.packetize(&payload, u32::MAX)?;
 
     packetizer.skip_samples(u32::MAX);
 

webrtc/src/track/track_local/track_local_static_sample.rs

@@ -118,7 +118,7 @@ impl TrackLocalStaticSample {
             if sample.prev_dropped_packets > 0 {
                 packetizer.skip_samples(samples * sample.prev_dropped_packets as u32);
             }
-            packetizer.packetize(&sample.data, samples).await?
+            packetizer.packetize(&sample.data, samples)?
         } else {
             vec![]
         };