peer_connection: Bolt on send side simulcast

Introduces add_encoding method in RTP sender to add simulcast encodings.

webrtc/src/api/mod.rs

@@ -157,9 +157,11 @@ impl API {
         transport: Arc<RTCDtlsTransport>,
         interceptor: Arc<dyn Interceptor + Send + Sync>,
     ) -> RTCRtpSender {
+        let kind = track.as_ref().map(|t| t.kind()).unwrap_or_default();
         RTCRtpSender::new(
             self.setting_engine.get_receive_mtu(),
             track,
+            kind,
             transport,
             Arc::clone(&self.media_engine),
             interceptor,

webrtc/src/error.rs

@@ -199,6 +199,10 @@ pub enum Error {
     #[error("new track must be of the same kind as previous")]
     ErrRTPSenderNewTrackHasIncorrectKind,
 
+    /// ErrRTPSenderNewTrackHasIncorrectEnvelope indicates that the new track has a different envelope than the previous/original
+    #[error("new track must have the same envelope as previous")]
+    ErrRTPSenderNewTrackHasIncorrectEnvelope,
+
     /// ErrRTPSenderDataSent indicates that the sequence number transformer tries to be enabled after the data sending began
     #[error("Sequence number transformer must be enabled before sending data")]
     ErrRTPSenderDataSent,
@@ -328,6 +332,20 @@ pub enum Error {
     },
     #[error("Track must not be nil")]
     ErrRTPSenderTrackNil,
+    #[error("Sender has already been stopped")]
+    ErrRTPSenderStopped,
+    #[error("Sender Track has been removed or replaced to nil")]
+    ErrRTPSenderTrackRemoved,
+    #[error("Sender cannot add encoding as rid is empty")]
+    ErrRTPSenderRidNil,
+    #[error("Sender cannot add encoding as there is no base track")]
+    ErrRTPSenderNoBaseEncoding,
+    #[error("Sender cannot add encoding as provided track does not match base track")]
+    ErrRTPSenderBaseEncodingMismatch,
+    #[error("Sender cannot encoding due to RID collision")]
+    ErrRTPSenderRIDCollision,
+    #[error("Sender does not have track for RID")]
+    ErrRTPSenderNoTrackForRID,
     #[error("RTPSender must not be nil")]
     ErrRTPSenderNil,
     #[error("RTPReceiver must not be nil")]

webrtc/src/peer_connection/mod.rs

@@ -1410,6 +1410,7 @@ impl RTCPeerConnection {
                                 RTCRtpSender::new(
                                     receive_mtu,
                                     None,
+                                    kind,
                                     Arc::clone(&self.internal.dtls_transport),
                                     Arc::clone(&self.internal.media_engine),
                                     Arc::clone(&self.interceptor),
@@ -1608,7 +1609,10 @@ impl RTCPeerConnection {
         let current_transceivers = self.internal.rtp_transceivers.lock().await;
         for transceiver in &*current_transceivers {
             let sender = transceiver.sender().await;
-            if sender.is_negotiated() && !sender.has_sent() {
+            if !sender.track_encodings.lock().await.is_empty()
+                && sender.is_negotiated()
+                && !sender.has_sent()
+            {
                 sender.send(&sender.get_parameters().await).await?;
             }
         }

webrtc/src/peer_connection/peer_connection_internal.rs

@@ -14,6 +14,7 @@ use crate::stats::{
     InboundRTPStats, OutboundRTPStats, RTCStatsType, RemoteInboundRTPStats, RemoteOutboundRTPStats,
     StatsReportType,
 };
+use crate::track::track_local::track_local_static_sample::TrackLocalStaticSample;
 use crate::track::TrackStream;
 use crate::SDP_ATTRIBUTE_RID;
 
@@ -442,44 +443,60 @@ impl PeerConnectionInternal {
             .map(|value| value.direction)
             .unwrap_or(RTCRtpTransceiverDirection::Sendrecv);
 
-        if direction == RTCRtpTransceiverDirection::Unspecified {
-            return Err(Error::ErrPeerConnAddTransceiverFromKindSupport);
-        }
-
-        let interceptor = self
-            .interceptor
-            .upgrade()
-            .ok_or(Error::ErrInterceptorNotBind)?;
-        let receiver = Arc::new(RTCRtpReceiver::new(
-            self.setting_engine.get_receive_mtu(),
-            kind,
-            Arc::clone(&self.dtls_transport),
-            Arc::clone(&self.media_engine),
-            Arc::clone(&interceptor),
-        ));
+        let t = match direction {
+            RTCRtpTransceiverDirection::Sendonly | RTCRtpTransceiverDirection::Sendrecv => {
+                let codec = self
+                    .media_engine
+                    .get_codecs_by_kind(kind)
+                    .first()
+                    .map(|c| c.capability.clone())
+                    .ok_or(Error::ErrNoCodecsAvailable)?;
+                let track = Arc::new(TrackLocalStaticSample::new(
+                    codec,
+                    math_rand_alpha(16),
+                    math_rand_alpha(16),
+                ));
+                self.new_transceiver_from_track(direction, track).await?
+            }
+            RTCRtpTransceiverDirection::Recvonly => {
+                let interceptor = self
+                    .interceptor
+                    .upgrade()
+                    .ok_or(Error::ErrInterceptorNotBind)?;
+                let receiver = Arc::new(RTCRtpReceiver::new(
+                    self.setting_engine.get_receive_mtu(),
+                    kind,
+                    Arc::clone(&self.dtls_transport),
+                    Arc::clone(&self.media_engine),
+                    Arc::clone(&interceptor),
+                ));
 
-        let sender = Arc::new(
-            RTCRtpSender::new(
-                self.setting_engine.get_receive_mtu(),
-                None,
-                Arc::clone(&self.dtls_transport),
-                Arc::clone(&self.media_engine),
-                interceptor,
-                false,
-            )
-            .await,
-        );
+                let sender = Arc::new(
+                    RTCRtpSender::new(
+                        self.setting_engine.get_receive_mtu(),
+                        None,
+                        kind,
+                        Arc::clone(&self.dtls_transport),
+                        Arc::clone(&self.media_engine),
+                        interceptor,
+                        false,
+                    )
+                    .await,
+                );
 
-        let t = RTCRtpTransceiver::new(
-            receiver,
-            sender,
-            direction,
-            kind,
-            vec![],
-            Arc::clone(&self.media_engine),
-            Some(Box::new(self.make_negotiation_needed_trigger())),
-        )
-        .await;
+                RTCRtpTransceiver::new(
+                    receiver,
+                    sender,
+                    direction,
+                    kind,
+                    vec![],
+                    Arc::clone(&self.media_engine),
+                    Some(Box::new(self.make_negotiation_needed_trigger())),
+                )
+                .await
+            }
+            _ => return Err(Error::ErrPeerConnAddTransceiverFromKindSupport),
+        };
 
         self.add_rtp_transceiver(Arc::clone(&t)).await;
 
@@ -512,6 +529,7 @@ impl PeerConnectionInternal {
             RTCRtpSender::new(
                 self.setting_engine.get_receive_mtu(),
                 Some(Arc::clone(&track)),
+                track.kind(),
                 Arc::clone(&self.dtls_transport),
                 Arc::clone(&self.media_engine),
                 Arc::clone(&interceptor),
@@ -1343,32 +1361,29 @@ impl PeerConnectionInternal {
         }
         let mut track_infos = vec![];
         for transceiver in transceivers {
-            let sender = transceiver.sender().await;
-
             let mid = match transceiver.mid() {
                 Some(mid) => mid,
                 None => continue,
             };
 
-            let track = match sender.track().await {
-                Some(track) => track,
-                None => continue,
-            };
-
-            let track_id = track.id().to_string();
-            let kind = match track.kind() {
-                RTPCodecType::Unspecified => continue,
-                RTPCodecType::Audio => "audio",
-                RTPCodecType::Video => "video",
-            };
+            let sender = transceiver.sender().await;
+            let track_encodings = sender.track_encodings.lock().await;
+            for encoding in track_encodings.iter() {
+                let track_id = encoding.track.id().to_string();
+                let kind = match encoding.track.kind() {
+                    RTPCodecType::Unspecified => continue,
+                    RTPCodecType::Audio => "audio",
+                    RTPCodecType::Video => "video",
+                };
 
-            track_infos.push(TrackInfo {
-                track_id,
-                ssrc: sender.ssrc,
-                mid,
-                rid: None,
-                kind,
-            });
+                track_infos.push(TrackInfo {
+                    track_id,
+                    ssrc: encoding.ssrc,
+                    mid: mid.to_owned(),
+                    rid: encoding.track.rid().map(Into::into),
+                    kind,
+                });
+            }
         }
 
         let stream_stats = self

webrtc/src/peer_connection/sdp/mod.rs

@@ -583,12 +583,32 @@ pub(crate) async fn add_transceiver_sdp(
     for mt in transceivers {
         let sender = mt.sender().await;
         if let Some(track) = sender.track().await {
-            media = media.with_media_source(
-                sender.ssrc,
-                track.stream_id().to_owned(), /* cname */
-                track.stream_id().to_owned(), /* streamLabel */
-                track.id().to_owned(),
-            );
+            let send_parameters = sender.get_parameters().await;
+            for encoding in &send_parameters.encodings {
+                media = media.with_media_source(
+                    encoding.ssrc,
+                    track.stream_id().to_owned(), /* cname */
+                    track.stream_id().to_owned(), /* streamLabel */
+                    track.id().to_owned(),
+                );
+            }
+
+            if send_parameters.encodings.len() > 1 {
+                let mut send_rids = Vec::with_capacity(send_parameters.encodings.len());
+
+                for encoding in &send_parameters.encodings {
+                    media = media.with_value_attribute(
+                        SDP_ATTRIBUTE_RID.to_owned(),
+                        format!("{} send", encoding.rid),
+                    );
+                    send_rids.push(encoding.rid.to_string());
+                }
+
+                media = media.with_value_attribute(
+                    SDP_ATTRIBUTE_SIMULCAST.to_owned(),
+                    format!("send {}", send_rids.join(";")),
+                );
+            }
 
             // Send msid based on the configured track if we haven't already
             // sent on this sender. If we have sent we must keep the msid line consistent, this

webrtc/src/peer_connection/sdp/sdp_test.rs

@@ -650,6 +650,7 @@ async fn test_media_description_fingerprints() -> Result<()> {
                 RTCRtpSender::new(
                     api.setting_engine.get_receive_mtu(),
                     Some(track),
+                    RTPCodecType::Video,
                     Arc::new(RTCDtlsTransport::default()),
                     Arc::clone(&api.media_engine),
                     Arc::clone(&interceptor),