Consider first packet when reading Simulcast IDs

peerconnection.go

@@ -1784,7 +1784,20 @@
 		return err
 	}
 
+	// try to read simulcast IDs from the packet we already have
 	var mid, rid, rsid string
+	if _, _, err = handleUnknownRTPPacket(
+		b[:i], uint8(midExtensionID), //nolint:gosec // G115
+		uint8(streamIDExtensionID),       //nolint:gosec // G115
+		uint8(repairStreamIDExtensionID), //nolint:gosec // G115
+		&mid,
+		&rid,
+		&rsid,
+	); err != nil {
+		return err
+	}
+
+	// if the first packet didn't contain simuilcast IDs, then probe more packets
 	var paddingOnly bool
 	for readCount := 0; readCount <= simulcastProbeCount; readCount++ {
 		if mid == "" || (rid == "" && rsid == "") {

peerconnection_media_test.go

@@ -1072,7 +1072,7 @@
 }
 
 func TestPeerConnection_Simulcast_Probe(t *testing.T) { //nolint:cyclop
 	lim := test.TimeOut(time.Second * 30) //nolint
 	defer lim.Stop()
 
 	report := test.CheckRoutines(t)
@@ -1131,6 +1131,106 @@
 		close(testFinished)
 	})
 
+	// Assert that we can send just one packet with Simulcast IDs (using extensions) and they will be properly received
+	t.Run("ExtractIDs", func(t *testing.T) {
+		offerer, answerer, err := newPair()
+		assert.NoError(t, err)
+
+		rids := []string{"layer_1", "layer_2", "layer_3"}
+		ridSelected := rids[0]
+
+		vp8WriterA, err := NewTrackLocalStaticRTP(
+			RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion1", WithRTPStreamID(rids[0]),
+		)
+		assert.NoError(t, err)
+
+		vp8WriterB, err := NewTrackLocalStaticRTP(
+			RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion1", WithRTPStreamID(rids[1]),
+		)
+		assert.NoError(t, err)
+
+		vp8WriterC, err := NewTrackLocalStaticRTP(
+			RTPCodecCapability{MimeType: MimeTypeVP8}, "video", "pion1", WithRTPStreamID(rids[2]),
+		)
+		assert.NoError(t, err)
+
+		sender, err := offerer.AddTrack(vp8WriterA)
+		assert.NoError(t, err)
+		assert.NotNil(t, sender)
+
+		assert.NoError(t, sender.AddEncoding(vp8WriterB))
+		assert.NoError(t, sender.AddEncoding(vp8WriterC))
+
+		assert.NoError(t, signalPair(offerer, answerer))
+
+		answerer.OnTrack(func(remote *TrackRemote, receiver *RTPReceiver) {
+			assert.Equal(t, remote.rid, ridSelected)
+		})
+
+		peerConnectionConnected := untilConnectionState(PeerConnectionStateConnected, offerer, answerer)
+		peerConnectionConnected.Wait()
+
+		ticker := time.NewTicker(time.Millisecond * 20)
+		defer ticker.Stop()
+		testFinished := make(chan struct{})
+		seenOneStream, seenOneStreamCancel := context.WithCancel(context.Background())
+
+		go func() {
+			sentOnePacket := false
+
+			senderTrack := vp8WriterA
+
+			for {
+				select {
+				case <-testFinished:
+					return
+				case <-ticker.C:
+					answerer.dtlsTransport.lock.Lock()
+					if len(answerer.dtlsTransport.simulcastStreams) >= 1 {
+						seenOneStreamCancel()
+					}
+					answerer.dtlsTransport.lock.Unlock()
+
+					senderTrack.mu.Lock()
+
+					// We send just one packet with the RID, that's the point of this test
+					if !sentOnePacket && len(senderTrack.bindings) > 0 {
+						sentOnePacket = true
+
+						midExtensionID, _, _ := answerer.api.mediaEngine.getHeaderExtensionID(
+							RTPHeaderExtensionCapability{sdp.SDESMidURI},
+						)
+						assert.Greater(t, midExtensionID, 0)
+
+						streamIDExtensionID, _, _ := answerer.api.mediaEngine.getHeaderExtensionID(
+							RTPHeaderExtensionCapability{sdp.SDESRTPStreamIDURI},
+						)
+						assert.Greater(t, streamIDExtensionID, 0)
+
+						header := &rtp.Header{
+							Version: 2,
+							SSRC:    util.RandUint32(),
+						}
+						header.Extension = true
+						header.ExtensionProfile = 0x1000
+						assert.NoError(t, header.SetExtension(uint8(midExtensionID), []byte("0")))
+						assert.NoError(t, header.SetExtension(uint8(streamIDExtensionID), []byte(ridSelected)))
+
+						_, err = senderTrack.bindings[0].writeStream.WriteRTP(header, []byte{0, 1, 2, 3, 4, 5})
+						assert.NoError(t, err)
+					}
+
+					senderTrack.mu.Unlock()
+				}
+			}
+		}()
+
+		<-seenOneStream.Done()
+
+		closePairNow(t, offerer, answerer)
+		close(testFinished)
+	})
+
 	// Assert that NonSimulcast Traffic isn't incorrectly broken by the probe
 	t.Run("Break NonSimulcast", func(t *testing.T) {
 		unhandledSimulcastError := make(chan struct{})