Automatically configure RTX codecs

Author: 3DRX

mediaengine.go

@@ -245,6 +245,44 @@ func (m *MediaEngine) RegisterCodec(codec RTPCodecParameters, typ RTPCodecType)
 	return err
 }
 
+func (m *MediaEngine) autoConfigRTXCodecs() error {
+	additionalRTXCodecs := []RTPCodecParameters{}
+	for _, codec := range m.videoCodecs {
+		// ignore FEC & RTX
+		if strings.Contains(codec.MimeType, MimeTypeFlexFEC) || codec.MimeType == MimeTypeRTX {
+			continue
+		}
+		haveNACK := false
+		for _, fb := range codec.RTCPFeedback {
+			if fb.Type == "nack" {
+				haveNACK = true
+
+				break
+			}
+		}
+		if haveNACK {
+			additionalRTXCodecs = append(additionalRTXCodecs, RTPCodecParameters{
+				RTPCodecCapability: RTPCodecCapability{
+					MimeType:     MimeTypeRTX,
+					ClockRate:    90000,
+					Channels:     0,
+					SDPFmtpLine:  fmt.Sprintf("apt=%d", codec.PayloadType),
+					RTCPFeedback: nil,
+				},
+				PayloadType: codec.PayloadType + 1,
+			})
+		}
+	}
+	for i := range additionalRTXCodecs {
+		err := m.RegisterCodec(additionalRTXCodecs[i], RTPCodecTypeVideo)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // RegisterHeaderExtension adds a header extension to the MediaEngine
 // To determine the negotiated value use `GetHeaderExtensionID` after signaling is complete.
 //

mediaengine_test.go

@@ -896,3 +896,158 @@ a=rtcp-fb:96 nack
 		runTest(t, true)
 	})
 }
+
+func TestAutoConfigRTXCodecs(t *testing.T) {
+	for _, test := range []struct {
+		Original       []RTPCodecParameters
+		ExpectedResult []RTPCodecParameters
+		ExpectedError  error
+	}{
+		{
+			// no video codec
+			Original: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:     MimeTypeFlexFEC03,
+						ClockRate:    90000,
+						Channels:     0,
+						SDPFmtpLine:  "repair-window=10000000",
+						RTCPFeedback: nil,
+					},
+				},
+			},
+			ExpectedResult: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:     MimeTypeFlexFEC03,
+						ClockRate:    90000,
+						Channels:     0,
+						SDPFmtpLine:  "repair-window=10000000",
+						RTCPFeedback: nil,
+					},
+				},
+			},
+			ExpectedError: nil,
+		},
+		{
+			// one video codec with no nack rtcp feedback
+			Original: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:     MimeTypeH265,
+						ClockRate:    90000,
+						Channels:     0,
+						SDPFmtpLine:  "",
+						RTCPFeedback: nil,
+					},
+				},
+			},
+			ExpectedResult: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:     MimeTypeH265,
+						ClockRate:    90000,
+						Channels:     0,
+						SDPFmtpLine:  "",
+						RTCPFeedback: nil,
+					},
+				},
+			},
+			ExpectedError: nil,
+		},
+		{
+			// one video codec with nack and pli rtcp feedback
+			Original: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:    MimeTypeH265,
+						ClockRate:   90000,
+						Channels:    0,
+						SDPFmtpLine: "",
+						RTCPFeedback: []RTCPFeedback{
+							{Type: "nack", Parameter: ""},
+							{Type: "nack", Parameter: "pli"},
+						},
+					},
+				},
+			},
+			ExpectedResult: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:    MimeTypeH265,
+						ClockRate:   90000,
+						Channels:    0,
+						SDPFmtpLine: "",
+						RTCPFeedback: []RTCPFeedback{
+							{Type: "nack", Parameter: ""},
+							{Type: "nack", Parameter: "pli"},
+						},
+					},
+				},
+				{
+					PayloadType: 2,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:     MimeTypeRTX,
+						ClockRate:    90000,
+						Channels:     0,
+						SDPFmtpLine:  "apt=1",
+						RTCPFeedback: nil,
+					},
+				},
+			},
+			ExpectedError: nil,
+		},
+		{
+			// multiple video codec, expect error because of PayloadType collision
+			Original: []RTPCodecParameters{
+				{
+					PayloadType: 1,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:    MimeTypeH265,
+						ClockRate:   90000,
+						Channels:    0,
+						SDPFmtpLine: "",
+						RTCPFeedback: []RTCPFeedback{
+							{Type: "nack", Parameter: ""},
+							{Type: "nack", Parameter: "pli"},
+						},
+					},
+				},
+				{
+					PayloadType: 2,
+					RTPCodecCapability: RTPCodecCapability{
+						MimeType:    MimeTypeVP8,
+						ClockRate:   90000,
+						Channels:    0,
+						SDPFmtpLine: "",
+						RTCPFeedback: []RTCPFeedback{
+							{Type: "nack", Parameter: ""},
+							{Type: "nack", Parameter: "pli"},
+						},
+					},
+				},
+			},
+			ExpectedResult: nil,
+			ExpectedError:  ErrCodecAlreadyRegistered,
+		},
+	} {
+		m := &MediaEngine{
+			videoCodecs: test.Original,
+		}
+		err := m.autoConfigRTXCodecs()
+		assert.Equal(t, err, test.ExpectedError)
+		if err == nil {
+			for i := range m.videoCodecs {
+				// ignore for following assert
+				m.videoCodecs[i].statsID = ""
+			}
+			assert.Equal(t, m.videoCodecs, test.ExpectedResult)
+		}
+	}
+}

peerconnection.go

@@ -142,8 +142,9 @@ func (api *API) NewPeerConnection(configuration Configuration) (*PeerConnection,
 	pc.iceConnectionState.Store(ICEConnectionStateNew)
 	pc.connectionState.Store(PeerConnectionStateNew)
 
-	i, err := api.interceptorRegistry.Build("")
-	if err != nil {
+	var i interceptor.Interceptor
+	var err error
+	if i, err = api.interceptorRegistry.Build(""); err != nil {
 		return nil, err
 	}
 
@@ -152,6 +153,12 @@ func (api *API) NewPeerConnection(configuration Configuration) (*PeerConnection,
 		interceptor:   i,
 	}
 
+	if api.settingEngine.autoConfigRTXCodec {
+		if err = api.mediaEngine.autoConfigRTXCodecs(); err != nil {
+			return nil, err
+		}
+	}
+
 	if api.settingEngine.disableMediaEngineCopy {
 		pc.api.mediaEngine = api.mediaEngine
 	} else {

settingengine.go

@@ -105,6 +105,7 @@ type SettingEngine struct {
 	fireOnTrackBeforeFirstRTP                 bool
 	disableCloseByDTLS                        bool
 	dataChannelBlockWrite                     bool
+	autoConfigRTXCodec                        bool
 }
 
 func (e *SettingEngine) getSCTPMaxMessageSize() uint32 {
@@ -540,3 +541,8 @@ func (e *SettingEngine) SetFireOnTrackBeforeFirstRTP(fireOnTrackBeforeFirstRTP b
 func (e *SettingEngine) DisableCloseByDTLS(isEnabled bool) {
 	e.disableCloseByDTLS = isEnabled
 }
+
+// AutoConfigRTXCodec sets if the RTX codec should be automatically configured.
+func (e *SettingEngine) AutoConfigRTXCodec(autoConfigRTXCodec bool) {
+	e.autoConfigRTXCodec = autoConfigRTXCodec
+}

settingengine_test.go

@@ -464,3 +464,50 @@ func TestEnableDataChannelBlockWrite(t *testing.T) {
 	assert.ErrorIs(t, err, context.DeadlineExceeded)
 	closePairNow(t, offer, answer)
 }
+
+func TestAutoConfigRTXCodec(t *testing.T) {
+	settingEngine := SettingEngine{}
+	settingEngine.DisableMediaEngineCopy(true)
+	settingEngine.AutoConfigRTXCodec(true)
+	mediaEngine := &MediaEngine{}
+	err := mediaEngine.RegisterCodec(
+		RTPCodecParameters{
+			PayloadType: 96,
+			RTPCodecCapability: RTPCodecCapability{
+				MimeType:  MimeTypeVP8,
+				ClockRate: 90000,
+			},
+		},
+		RTPCodecTypeVideo,
+	)
+	assert.Equal(t, err, nil)
+	api := NewAPI(
+		WithMediaEngine(mediaEngine),
+		WithSettingEngine(settingEngine),
+	)
+	config := Configuration{
+		ICEServers: []ICEServer{
+			{
+				URLs: []string{"stun:stun.l.google.com:19302"},
+			},
+		},
+	}
+	_, err = api.NewPeerConnection(config)
+	assert.Equal(t, err, nil)
+	for i := range mediaEngine.videoCodecs {
+		mediaEngine.videoCodecs[i].statsID = ""
+	}
+	assert.Equal(t, len(mediaEngine.videoCodecs), 2)
+	assert.Equal(t, mediaEngine.videoCodecs[1],
+		RTPCodecParameters{
+			PayloadType: 97,
+			RTPCodecCapability: RTPCodecCapability{
+				MimeType:     MimeTypeRTX,
+				ClockRate:    90000,
+				Channels:     0,
+				SDPFmtpLine:  "apt=96",
+				RTCPFeedback: nil,
+			},
+		},
+	)
+}