webrtc-rs 0.8.0 (#51)

dasxran · web-flow · commit b96fd4bb23d4 · 2024-10-12T22:32:39.000+01:00
* webrtc-rs 0.8.0

* rs-client
diff --git a/webrtc-rs/client/Cargo.toml b/webrtc-rs/client/Cargo.toml
@@ -6,8 +6,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-webrtc = "=0.2.1"
-interceptor = "=0.4.0"
+webrtc = "=0.8.0"
 tokio = { version = "1.12.0", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
diff --git a/webrtc-rs/client/src/main.rs b/webrtc-rs/client/src/main.rs
@@ -1,23 +1,25 @@
 use anyhow::Result;
 use clap::{App, AppSettings, Arg};
 use hyper::{Body, Client, Method, Request};
-use interceptor::registry::Registry;
 use std::io::Write;
 use std::sync::Arc;
 use tokio::time::Duration;
 use webrtc::api::interceptor_registry::register_default_interceptors;
 use webrtc::api::media_engine::{MediaEngine, MIME_TYPE_VP8};
 use webrtc::api::APIBuilder;
-use webrtc::media::rtp::rtp_codec::{RTCRtpCodecCapability, RTCRtpCodecParameters, RTPCodecType};
-use webrtc::media::track::track_local::track_local_static_rtp::TrackLocalStaticRTP;
-use webrtc::media::track::track_local::TrackLocal;
-use webrtc::peer::configuration::RTCConfiguration;
-use webrtc::peer::ice::ice_candidate::RTCIceCandidate;
-use webrtc::peer::ice::ice_connection_state::RTCIceConnectionState;
-use webrtc::peer::ice::ice_server::RTCIceServer;
-use webrtc::peer::peer_connection_state::RTCPeerConnectionState;
-use webrtc::peer::sdp::session_description::RTCSessionDescription;
-use webrtc::peer::signaling_state::RTCSignalingState;
+use webrtc::ice_transport::ice_candidate::RTCIceCandidate;
+use webrtc::ice_transport::ice_connection_state::RTCIceConnectionState;
+use webrtc::ice_transport::ice_server::RTCIceServer;
+use webrtc::interceptor::registry::Registry;
+use webrtc::peer_connection::configuration::RTCConfiguration;
+use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
+use webrtc::peer_connection::sdp::session_description::RTCSessionDescription;
+use webrtc::peer_connection::signaling_state::RTCSignalingState;
+use webrtc::rtp_transceiver::rtp_codec::{
+    RTCRtpCodecCapability, RTCRtpCodecParameters, RTPCodecType,
+};
+use webrtc::track::track_local::track_local_static_rtp::TrackLocalStaticRTP;
+use webrtc::track::track_local::TrackLocal;
 
 //const ECHO_TEST_SERVER_URL: &str = "http://localhost:8080/offer";
 const CONNECTION_ATTEMPT_TIMEOUT_SECONDS: u64 = 10;
@@ -150,14 +152,12 @@ async fn main() -> Result<()> {
     });
 
     // Add ICE candidates to the local offer (simulates non-trickle).
-    peer_connection
-        .on_ice_candidate(Box::new(move |c: Option<RTCIceCandidate>| {
-            if c.is_none() {
-                //println!(peer_connection.LocalDescription())
-            }
-            Box::pin(async {})
-        }))
-        .await;
+    peer_connection.on_ice_candidate(Box::new(move |c: Option<RTCIceCandidate>| {
+        if c.is_none() {
+            //println!(peer_connection.LocalDescription())
+        }
+        Box::pin(async {})
+    }));
 
     // Create an offer to send to the other process
     let offer = peer_connection.create_offer(None).await?;
@@ -167,17 +167,17 @@ async fn main() -> Result<()> {
 
     // Set the handler for ICE connection state
     // This will notify you when the peer has connected/disconnected
-    peer_connection
-        .on_ice_connection_state_change(Box::new(|connection_state: RTCIceConnectionState| {
+    peer_connection.on_ice_connection_state_change(Box::new(
+        |connection_state: RTCIceConnectionState| {
             println!("ICE connection state has changed {}.", connection_state);
             Box::pin(async {})
-        }))
-        .await;
+        },
+    ));
 
     let (done_tx, mut done_rx) = tokio::sync::mpsc::channel::<()>(1);
     let done_tx = Arc::new(done_tx);
-    peer_connection
-        .on_peer_connection_state_change(Box::new(move |state: RTCPeerConnectionState| {
+    peer_connection.on_peer_connection_state_change(Box::new(
+        move |state: RTCPeerConnectionState| {
             println!("Peer connection state has changed to {}.", state);
 
             let done_tx2 = Arc::clone(&done_tx);
@@ -191,15 +191,13 @@ async fn main() -> Result<()> {
                     std::process::exit(SUCCESS_RETURN_VALUE);
                 }
             })
-        }))
-        .await;
+        },
+    ));
 
-    peer_connection
-        .on_signaling_state_change(Box::new(|state: RTCSignalingState| {
-            println!("Signaling state has changed to {}.", state);
-            Box::pin(async {})
-        }))
-        .await;
+    peer_connection.on_signaling_state_change(Box::new(|state: RTCSignalingState| {
+        println!("Signaling state has changed to {}.", state);
+        Box::pin(async {})
+    }));
 
     // Create channel that is blocked until ICE Gathering is complete
     let mut gather_complete = peer_connection.gathering_complete_promise().await;
diff --git a/webrtc-rs/server/Cargo.toml b/webrtc-rs/server/Cargo.toml
@@ -6,8 +6,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-webrtc = "=0.2.1"
-interceptor = "=0.4.0"
+webrtc = "=0.8.0"
 tokio = { version = "1.12.0", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
diff --git a/webrtc-rs/server/src/main.rs b/webrtc-rs/server/src/main.rs
@@ -3,7 +3,6 @@ use async_trait::async_trait;
 use clap::{App, AppSettings, Arg};
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Request, Response, Server, StatusCode};
-use interceptor::registry::Registry;
 use std::any::Any;
 use std::io::Write;
 use std::net::SocketAddr;
@@ -14,17 +13,19 @@ use tokio_util::codec::{BytesCodec, FramedRead};
 use webrtc::api::interceptor_registry::register_default_interceptors;
 use webrtc::api::media_engine::MediaEngine;
 use webrtc::api::APIBuilder;
-use webrtc::media::rtp::rtp_codec::{RTCRtpCodecParameters, RTPCodecType};
-use webrtc::media::rtp::rtp_receiver::RTCRtpReceiver;
-use webrtc::media::track::track_local::{TrackLocal, TrackLocalContext};
-use webrtc::media::track::track_remote::TrackRemote;
-use webrtc::peer::configuration::RTCConfiguration;
-use webrtc::peer::ice::ice_connection_state::RTCIceConnectionState;
-use webrtc::peer::ice::ice_server::RTCIceServer;
-use webrtc::peer::peer_connection::RTCPeerConnection;
-use webrtc::peer::peer_connection_state::RTCPeerConnectionState;
-use webrtc::peer::sdp::session_description::RTCSessionDescription;
-use webrtc::peer::signaling_state::RTCSignalingState;
+use webrtc::ice_transport::ice_connection_state::RTCIceConnectionState;
+use webrtc::ice_transport::ice_server::RTCIceServer;
+use webrtc::interceptor::registry::Registry;
+use webrtc::peer_connection::configuration::RTCConfiguration;
+use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
+use webrtc::peer_connection::sdp::session_description::RTCSessionDescription;
+use webrtc::peer_connection::signaling_state::RTCSignalingState;
+use webrtc::peer_connection::RTCPeerConnection;
+use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecParameters, RTPCodecType};
+use webrtc::rtp_transceiver::rtp_receiver::RTCRtpReceiver;
+use webrtc::rtp_transceiver::RTCRtpTransceiver;
+use webrtc::track::track_local::{TrackLocal, TrackLocalContext};
+use webrtc::track::track_remote::TrackRemote;
 
 #[macro_use]
 extern crate lazy_static;
@@ -173,8 +174,7 @@ async fn process_offer(req: Request<Body>) -> Result<Response<Body>, hyper::Erro
             });
         }
         Box::pin(async {})
-    }))
-    .await;
+    }));
 
     let audio_track = Arc::new(EchoTrack::new(
         "audio".to_owned(),
@@ -203,52 +203,51 @@ async fn process_offer(req: Request<Body>) -> Result<Response<Body>, hyper::Erro
     };
 
     pc.on_track(Box::new(
-        move |track: Option<Arc<TrackRemote>>, _receiver: Option<Arc<RTCRtpReceiver>>| {
+        move |track: Arc<TrackRemote>,
+              _receiver: Arc<RTCRtpReceiver>,
+              _transceiver: Arc<RTCRtpTransceiver>| {
             let audio_track2 = Arc::clone(&audio_track);
             let video_track2 = Arc::clone(&video_track);
             Box::pin(async move {
-                if let Some(track) = track {
-                    let mime_type = track.codec().await.capability.mime_type;
-                    let out_track = if mime_type.starts_with("audio") {
-                        audio_track2
-                    } else {
-                        video_track2
+                let mime_type = track.codec().capability.mime_type;
+                let out_track = if mime_type.starts_with("audio") {
+                    audio_track2
+                } else {
+                    video_track2
+                };
+
+                println!(
+                    "Track has started, of type {}: {}",
+                    track.payload_type(),
+                    mime_type
+                );
+                tokio::spawn(async move {
+                    let (ssrc, write_stream) = {
+                        let ctx = out_track.ctx.lock().await;
+                        (ctx[0].ssrc(), ctx[0].write_stream())
                     };
+                    while let Ok((mut rtp, _)) = track.read_rtp().await {
+                        rtp.header.ssrc = ssrc;
+                        if let Some(ws) = &write_stream {
+                            if let Err(err) = ws.write_rtp(&rtp).await {
+                                println!("write_stream.write_rtp err: {}", err);
+                                break;
+                            }
+                        } else {
+                            println!("write_stream is none");
+                            break;
+                        }
+                    }
 
                     println!(
-                        "Track has started, of type {}: {}",
+                        "Track has ended, of type {}: {}",
                         track.payload_type(),
                         mime_type
                     );
-                    tokio::spawn(async move {
-                        let (ssrc, write_stream) = {
-                            let ctx = out_track.ctx.lock().await;
-                            (ctx[0].ssrc(), ctx[0].write_stream())
-                        };
-                        while let Ok((mut rtp, _)) = track.read_rtp().await {
-                            rtp.header.ssrc = ssrc;
-                            if let Some(ws) = &write_stream {
-                                if let Err(err) = ws.write_rtp(&rtp).await {
-                                    println!("write_stream.write_rtp err: {}", err);
-                                    break;
-                                }
-                            } else {
-                                println!("write_stream is none");
-                                break;
-                            }
-                        }
-
-                        println!(
-                            "Track has ended, of type {}: {}",
-                            track.payload_type(),
-                            mime_type
-                        );
-                    });
-                }
+                });
             })
         },
-    ))
-    .await;
+    ));
 
     let stats_id = pc.get_stats_id().to_owned();
     pc.on_peer_connection_state_change(Box::new(move |state: RTCPeerConnectionState| {
@@ -257,15 +256,13 @@ async fn process_offer(req: Request<Body>) -> Result<Response<Body>, hyper::Erro
             stats_id, state
         );
         Box::pin(async {})
-    }))
-    .await;
+    }));
 
     let stats_id = pc.get_stats_id().to_owned();
     pc.on_signaling_state_change(Box::new(move |state: RTCSignalingState| {
         println!("Signaling state {} has changed to {}.", stats_id, state);
         Box::pin(async {})
-    }))
-    .await;
+    }));
 
     if let Err(err) = pc.set_remote_description(offer).await {
         panic!("{}", err);
@@ -418,7 +415,10 @@ impl EchoTrack {
 
 #[async_trait]
 impl TrackLocal for EchoTrack {
-    async fn bind(&self, c: &TrackLocalContext) -> std::result::Result<RTCRtpCodecParameters, webrtc::Error> {
+    async fn bind(
+        &self,
+        c: &TrackLocalContext,
+    ) -> std::result::Result<RTCRtpCodecParameters, webrtc::Error> {
         let mut ctx = self.ctx.lock().await;
         ctx.push(c.clone());
 
