Tentative first pass at making simulcast egest possible

interceptor/src/stream_info.rs

@@ -11,6 +11,7 @@ pub struct RTPHeaderExtension {
 #[derive(Default, Debug, Clone)]
 pub struct StreamInfo {
     pub id: String,
+    pub rid: String,
     pub attributes: Attributes,
     pub ssrc: u32,
     pub payload_type: u8,

webrtc/src/error.rs

@@ -197,6 +197,23 @@ pub enum Error {
     #[error("new track must be of the same kind as previous")]
     ErrRTPSenderNewTrackHasIncorrectKind,
 
+    #[error("Sender cannot encoding due to RID collision")]
+    ErrRTPSenderRIDCollision,
+
+    #[error("Sender cannot add encoding as provided track does not match base track")]
+    ErrRTPSenderBaseEncodingMismatch,
+
+    /// ErrRTPSenderStopped indicates the sender was already stopped
+    #[error("Sender has already been stopped")]
+    ErrRTPSenderStopped,
+
+    /// ErrRTPSenderRidNil indicates that the track RID was empty
+    #[error("Sender cannot add encoding as rid is empty")]
+    ErrRTPSenderRidNil,
+
+    #[error("Sender cannot add encoding as there is no base track")]
+    ErrRTPSenderNoBaseEncoding,
+
     /// ErrUnbindFailed indicates that a TrackLocal was not able to be unbind
     #[error("failed to unbind TrackLocal from PeerConnection")]
     ErrUnbindFailed,

webrtc/src/peer_connection/mod.rs

@@ -490,16 +490,17 @@ impl RTCPeerConnection {
                             // local description so we can compare all of them. For no we only
                             // consider the first one.
 
-                            let stream_ids = sender.associated_media_stream_ids();
-                            // Different number of lines, 1 vs 0
-                            if stream_ids.is_empty() {
-                                return true;
-                            }
+                            // TODO: Go and see what Pion does these days here
+                            //                            let stream_ids = sender.associated_media_stream_ids();
+                            //                            // Different number of lines, 1 vs 0
+                            //                            if stream_ids.is_empty() {
+                            return true;
+                            //                            }
 
                             // different stream id
-                            if dmsid.split_whitespace().next() != Some(&stream_ids[0]) {
-                                return true;
-                            }
+                            //                            if dmsid.split_whitespace().next() != Some(&stream_ids[0]) {
+                            //                                return true;
+                            //                            }
                         }
                         match local_desc.sdp_type {
                             RTCSdpType::Offer => {

webrtc/src/peer_connection/peer_connection_internal.rs

@@ -1141,6 +1141,7 @@ impl PeerConnectionInternal {
                     let stream_info = create_stream_info(
                         "".to_owned(),
                         ssrc,
+                        "".to_owned(),
                         params.codecs[0].payload_type,
                         params.codecs[0].capability.clone(),
                         &params.header_extensions,
@@ -1535,20 +1536,23 @@ impl PeerConnectionInternal {
                 None => continue,
             };
 
-            let track_id = track.id().to_string();
             let kind = match track.kind() {
                 RTPCodecType::Unspecified => continue,
                 RTPCodecType::Audio => "audio",
                 RTPCodecType::Video => "video",
             };
 
-            track_infos.push(TrackInfo {
-                track_id,
-                ssrc: sender.ssrc,
-                mid: mid.clone(),
-                rid: None,
-                kind,
-            });
+            let encodings = sender.track_encodings.lock().await;
+            for e in encodings.iter() {
+                let track_id = track.id().to_string();
+                track_infos.push(TrackInfo {
+                    track_id,
+                    ssrc: e.ssrc,
+                    mid: mid.clone(),
+                    rid: Some(track.rid().to_owned()),
+                    kind,
+                });
+            }
         }
 
         let stream_stats = self

webrtc/src/peer_connection/sdp/mod.rs

@@ -540,55 +540,57 @@ pub(crate) async fn add_transceiver_sdp(
         );
     }
 
+    // This is equivalent to addSenderSDP in Pion (now)
     for mt in transceivers {
         if let Some(sender) = mt.sender().await {
+            let send_parameters = sender.get_parameters().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(),
-                );
-
-                // 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
-                // is handled below.
-                if !is_plan_b && sender.initial_track_id().is_none() {
-                    for stream_id in sender.associated_media_stream_ids() {
-                        media = media.with_property_attribute(format!(
-                            "msid:{} {}",
-                            stream_id,
-                            track.id()
-                        ));
+                for encoding in send_parameters.encodings.iter() {
+                    media = media.with_media_source(
+                        encoding.ssrc,
+                        track.stream_id().to_owned(), /* cname */
+                        track.stream_id().to_owned(), /* streamLabel */
+                        track.id().to_owned(),
+                    );
+
+                    // 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
+                    // is handled below.
+                    if !is_plan_b {
+                        // We need this?
+                        // related streams don't exist any more in pion (and nor should they?)
+
+                        // I this should become obsolete
+                        if sender.initial_track_id().is_none() {
+                            media = media.with_property_attribute(format!(
+                                "msid:{} {}",
+                                track.stream_id(),
+                                track.id()
+                            ));
+                            sender.set_initial_track_id(track.id().to_string())?;
+                        }
                     }
-
-                    sender.set_initial_track_id(track.id().to_string())?;
-                    break;
                 }
-            }
 
-            if !is_plan_b {
-                if let Some(track_id) = sender.initial_track_id() {
-                    // After we have include an msid attribute in an offer it must stay the same for
-                    // all subsequent offer even if the track or transceiver direction changes.
-                    //
-                    // [RFC 8829 Section 5.2.2](https://datatracker.ietf.org/doc/html/rfc8829#section-5.2.2)
-                    //
-                    // For RtpTransceivers that are not stopped, the "a=msid" line or
-                    // lines MUST stay the same if they are present in the current
-                    // description, regardless of changes to the transceiver's direction
-                    // or track.  If no "a=msid" line is present in the current
-                    // description, "a=msid" line(s) MUST be generated according to the
-                    // same rules as for an initial offer.
-                    for stream_id in sender.associated_media_stream_ids() {
-                        media = media
-                            .with_property_attribute(format!("msid:{} {}", stream_id, track_id));
-                    }
+                if send_parameters.encodings.len() > 1 {
+                    let mut send_rids: Vec<String> = vec![];
 
-                    break;
+                    for e in send_parameters.encodings.iter() {
+                        let mut s: String = e.rid.clone();
+                        s.push_str(" send");
+                        media = media.with_value_attribute("rid".into(), s);
+                        send_rids.push(e.rid.clone())
+                    }
+                    // Simulcast)
+                    let mut s: String = "send ".to_owned();
+                    s.push_str(send_rids.join(";").as_ref());
+                    media = media.with_value_attribute("simulcast".into(), s);
                 }
             }
         }
+        if !is_plan_b {
+            break;
+        }
     }
 
     let direction = match params.offered_direction {

webrtc/src/rtp_transceiver/mod.rs

@@ -132,6 +132,7 @@ pub struct RTCRtpTransceiverInit {
 pub(crate) fn create_stream_info(
     id: String,
     ssrc: SSRC,
+    rid: String,
     payload_type: PayloadType,
     codec: RTCRtpCodecCapability,
     webrtc_header_extensions: &[RTCRtpHeaderExtensionParameters],
@@ -154,6 +155,7 @@ pub(crate) fn create_stream_info(
 
     StreamInfo {
         id,
+        rid,
         attributes: Attributes::new(),
         ssrc,
         payload_type,

webrtc/src/rtp_transceiver/rtp_receiver/mod.rs

@@ -529,6 +529,7 @@ impl RTCRtpReceiver {
                     let stream_info = create_stream_info(
                         "".to_owned(),
                         encoding.ssrc,
+                        "".to_owned(),
                         0,
                         codec.clone(),
                         &global_params.header_extensions,
@@ -586,6 +587,7 @@ impl RTCRtpReceiver {
                 let stream_info = create_stream_info(
                     "".to_owned(),
                     rtx_ssrc,
+                    "".to_owned(),
                     0,
                     codec.clone(),
                     &global_params.header_extensions,