Add opt control transceiver re-use in recvonly

SetDisableTransceiverReuseInRecvonly controls if a
transceiver is re-used when its current direction is `recvonly`.

This is useful for the following scenario
  - Remote side sends `offer` with `sendonly` media section.
  - Local side creates transceiver in `SetRemoteDescription`
    and sets direction to `recvonly.
  - Local side calls `AddTrack`.
  - As the current direction is `recvonly`, the transceiver added
    above will be re-used. That will set the direction to `sendrecv`
    and the generated `answer` will have `sendrecv` for that
    media section.
  - That answer becomes incompatible as the offerer is using
    `sendonly`.

Note that local transceiver will be in `recvonly` for both `sendrecv`
and `sendonly` directions in the media section. If the `offer` did use
`sendrecv`, it is possible to re-use that transceiver for sending.
So, disabling re-use will prohibit re-use in the `sendrecv` case also
and hence is slightly wasteful.

Author: boks1971

peerconnection.go

@@ -1160,16 +1160,25 @@ func (pc *PeerConnection) SetRemoteDescription(desc SessionDescription) error {
 				// if transceiver is create by remote sdp, set prefer codec same as remote peer
 				if codecs, err := codecsFromMediaDescription(media); err == nil {
 					filteredCodecs := []RTPCodecParameters{}
+					filteredCodecsPartial := []RTPCodecParameters{}
 					for _, codec := range codecs {
-						if c, matchType := codecParametersFuzzySearch(
+						c, matchType := codecParametersFuzzySearch(
 							codec,
 							pc.api.mediaEngine.getCodecsByKind(kind),
-						); matchType == codecMatchExact {
+						)
+						switch matchType {
+						case codecMatchExact:
 							// if codec match exact, use payloadtype register to mediaengine
 							codec.PayloadType = c.PayloadType
 							filteredCodecs = append(filteredCodecs, codec)
+						case codecMatchPartial:
+							codec.PayloadType = c.PayloadType
+							filteredCodecsPartial = append(filteredCodecsPartial, codec)
+
+						default:
 						}
 					}
+					filteredCodecs = append(filteredCodecs, filteredCodecsPartial...)
 					_ = transceiver.SetCodecPreferences(filteredCodecs)
 				}
 
@@ -2096,7 +2105,8 @@ func (pc *PeerConnection) AddTrack(track TrackLocal) (*RTPSender, error) {
 		// But that will cause sdp inflate. So we only check currentDirection's current value,
 		// that's worked for all browsers.
 		if transceiver.kind == track.Kind() && transceiver.Sender() == nil &&
-			currentDirection != RTPTransceiverDirectionSendrecv && currentDirection != RTPTransceiverDirectionSendonly {
+			currentDirection != RTPTransceiverDirectionSendrecv && currentDirection != RTPTransceiverDirectionSendonly &&
+			(!pc.api.settingEngine.disableTransceiverReuseInRecvonly || currentDirection != RTPTransceiverDirectionRecvonly) {
 			sender, err := pc.api.NewRTPSender(track, pc.dtlsTransport)
 			if err == nil {
 				err = transceiver.SetSender(sender, track)

peerconnection_go_test.go

@@ -1422,6 +1422,10 @@ a=fmtp:125 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=42e01
 		_, matchType = codecParametersFuzzySearch(codecOfTr2, codecs)
 		assert.Equal(t, codecMatchExact, matchType)
 		assert.EqualValues(t, 94, codecOfTr2.PayloadType)
+		codecPartialMatchOfTr2 := pc.GetTransceivers()[1].getCodecs()[2]
+		_, matchType = codecParametersFuzzySearch(codecPartialMatchOfTr2, codecs)
+		assert.Equal(t, codecMatchPartial, matchType)
+		assert.EqualValues(t, 98, codecPartialMatchOfTr2.PayloadType)
 		assert.NoError(t, pc.Close())
 	})
 

peerconnection_media_test.go

@@ -707,41 +707,95 @@ func TestAddTransceiverFromTrackSendRecv(t *testing.T) {
 }
 
 func TestAddTransceiverAddTrack_Reuse(t *testing.T) {
-	pc, err := NewPeerConnection(Configuration{})
-	assert.NoError(t, err)
+	t.Run("reuse test", func(t *testing.T) {
+		pc, err := NewPeerConnection(Configuration{})
+		assert.NoError(t, err)
 
-	tr, err := pc.AddTransceiverFromKind(
-		RTPCodecTypeVideo,
-		RTPTransceiverInit{Direction: RTPTransceiverDirectionRecvonly},
-	)
-	assert.NoError(t, err)
+		tr, err := pc.AddTransceiverFromKind(
+			RTPCodecTypeVideo,
+			RTPTransceiverInit{Direction: RTPTransceiverDirectionRecvonly},
+		)
+		assert.NoError(t, err)
 
-	assert.Equal(t, []*RTPTransceiver{tr}, pc.GetTransceivers())
+		assert.Equal(t, []*RTPTransceiver{tr}, pc.GetTransceivers())
 
-	addTrack := func() (TrackLocal, *RTPSender) {
-		track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "foo", "bar")
+		addTrack := func() (TrackLocal, *RTPSender) {
+			track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "foo", "bar")
+			assert.NoError(t, err)
+
+			sender, err := pc.AddTrack(track)
+			assert.NoError(t, err)
+
+			return track, sender
+		}
+
+		track1, sender1 := addTrack()
+		assert.Equal(t, 1, len(pc.GetTransceivers()))
+		assert.Equal(t, sender1, tr.Sender())
+		assert.Equal(t, track1, tr.Sender().Track())
+		require.NoError(t, pc.RemoveTrack(sender1))
+
+		track2, _ := addTrack()
+		assert.Equal(t, 1, len(pc.GetTransceivers()))
+		assert.Equal(t, track2, tr.Sender().Track())
+
+		addTrack()
+		assert.Equal(t, 2, len(pc.GetTransceivers()))
+
+		assert.NoError(t, pc.Close())
+	})
+
+	t.Run("reuse disable test", func(t *testing.T) {
+		se := SettingEngine{}
+		se.SetDisableTransceiverReuseInRecvonly(true)
+		pc, err := NewAPI(WithSettingEngine(se)).NewPeerConnection(Configuration{})
 		assert.NoError(t, err)
 
-		sender, err := pc.AddTrack(track)
+		tr, err := pc.AddTransceiverFromKind(
+			RTPCodecTypeVideo,
+			RTPTransceiverInit{Direction: RTPTransceiverDirectionRecvonly},
+		)
 		assert.NoError(t, err)
 
-		return track, sender
-	}
+		assert.Equal(t, []*RTPTransceiver{tr}, pc.GetTransceivers())
 
-	track1, sender1 := addTrack()
-	assert.Equal(t, 1, len(pc.GetTransceivers()))
-	assert.Equal(t, sender1, tr.Sender())
-	assert.Equal(t, track1, tr.Sender().Track())
-	require.NoError(t, pc.RemoveTrack(sender1))
+		addTrack := func() (TrackLocal, *RTPSender) {
+			track, err := NewTrackLocalStaticSample(RTPCodecCapability{MimeType: MimeTypeVP8}, "foo", "bar")
+			assert.NoError(t, err)
 
-	track2, _ := addTrack()
-	assert.Equal(t, 1, len(pc.GetTransceivers()))
-	assert.Equal(t, track2, tr.Sender().Track())
+			sender, err := pc.AddTrack(track)
+			assert.NoError(t, err)
 
-	addTrack()
-	assert.Equal(t, 2, len(pc.GetTransceivers()))
+			return track, sender
+		}
 
-	assert.NoError(t, pc.Close())
+		// force direction to `recvonly` and ensure SettingEngine setting disables re-use
+		tr.setCurrentDirection(RTPTransceiverDirectionRecvonly)
+		addTrack()
+		assert.Equal(t, 2, len(pc.GetTransceivers()))
+
+		// the newly added transceiver above will have a sender, so not re-usable
+		_, sender := addTrack()
+		assert.Equal(t, 3, len(pc.GetTransceivers()))
+
+		// remove last added track to make that transceiver re-usable
+		require.NoError(t, pc.RemoveTrack(sender))
+
+		track, sender := addTrack()
+		assert.Equal(t, 3, len(pc.GetTransceivers()))
+		var matchedTransceiver *RTPTransceiver
+		for _, tr := range pc.GetTransceivers() {
+			if tr.Sender() == sender {
+				matchedTransceiver = tr
+
+				break
+			}
+		}
+		assert.NotNil(t, matchedTransceiver)
+		assert.Equal(t, track, matchedTransceiver.Sender().Track())
+
+		assert.NoError(t, pc.Close())
+	})
 }
 
 func TestAddTransceiverAddTrack_NewRTPSender_Error(t *testing.T) {

rtpcodec.go

@@ -5,6 +5,7 @@ package webrtc
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/pion/webrtc/v4/internal/fmtp"
@@ -155,6 +156,38 @@ func findRTXPayloadType(needle PayloadType, haystack []RTPCodecParameters) Paylo
 	return PayloadType(0)
 }
 
+// Given needle CodecParameters, returns if needle is RTX and
+// if primary codec corresponding to that needle is in the haystack of codecs.
+func primaryPayloadTypeForRTXExists(needle RTPCodecParameters, haystack []RTPCodecParameters) (
+	isRTX bool, primaryExists bool,
+) {
+	if !strings.EqualFold(needle.MimeType, MimeTypeRTX) {
+		return
+	}
+
+	isRTX = true
+	parsed := fmtp.Parse(needle.MimeType, needle.ClockRate, needle.Channels, needle.SDPFmtpLine)
+	aptPayload, ok := parsed.Parameter("apt")
+	if !ok {
+		return
+	}
+
+	primaryPayloadType, err := strconv.Atoi(aptPayload)
+	if err != nil || primaryPayloadType < 0 || primaryPayloadType > 255 {
+		return
+	}
+
+	for _, c := range haystack {
+		if c.PayloadType == PayloadType(primaryPayloadType) {
+			primaryExists = true
+
+			return
+		}
+	}
+
+	return
+}
+
 // For now, only FlexFEC is supported.
 func findFECPayloadType(haystack []RTPCodecParameters) PayloadType {
 	for _, c := range haystack {