webrtc: allow setting Opus bitrate (#1908) (#1985)

internal/core/webrtc_http_server.go

@@ -304,6 +304,7 @@ func (s *webRTCHTTPServer) onRequest(ctx *gin.Context) {
 				videoCodec:   ctx.Query("video_codec"),
 				audioCodec:   ctx.Query("audio_codec"),
 				videoBitrate: ctx.Query("video_bitrate"),
+				audioBitrate: ctx.Query("audio_bitrate"),
 			})
 			if res.err != nil {
 				if res.errStatusCode != 0 {

internal/core/webrtc_manager.go

@@ -137,6 +137,7 @@ type webRTCSessionNewReq struct {
 	videoCodec   string
 	audioCodec   string
 	videoBitrate string
+	audioBitrate string
 	res          chan webRTCSessionNewRes
 }
 

internal/core/webrtc_pc.go

@@ -11,62 +11,16 @@ import (
 	"github.com/bluenviron/mediamtx/internal/logger"
 )
 
-type peerConnection struct {
+var videoCodecs = map[string][]webrtc.RTPCodecParameters{
-	*webrtc.PeerConnection
+	"av1": {{
-	stateChangeMutex   sync.Mutex
-	localCandidateRecv chan *webrtc.ICECandidateInit
-	connected          chan struct{}
-	disconnected       chan struct{}
-	closed             chan struct{}
-	gatheringDone      chan struct{}
-}
-
-func newPeerConnection(
-	videoCodec string,
-	audioCodec string,
-	iceServers []webrtc.ICEServer,
-	iceHostNAT1To1IPs []string,
-	iceUDPMux ice.UDPMux,
-	iceTCPMux ice.TCPMux,
-	log logger.Writer,
-) (*peerConnection, error) {
-	configuration := webrtc.Configuration{ICEServers: iceServers}
-	settingsEngine := webrtc.SettingEngine{}
-
-	if len(iceHostNAT1To1IPs) != 0 {
-		settingsEngine.SetNAT1To1IPs(iceHostNAT1To1IPs, webrtc.ICECandidateTypeHost)
-	}
-
-	if iceUDPMux != nil {
-		settingsEngine.SetICEUDPMux(iceUDPMux)
-	}
-
-	if iceTCPMux != nil {
-		settingsEngine.SetICETCPMux(iceTCPMux)
-		settingsEngine.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeTCP4})
-	}
-
-	mediaEngine := &webrtc.MediaEngine{}
-
-	if videoCodec != "" || audioCodec != "" {
-		switch videoCodec {
-		case "av1":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:  webrtc.MimeTypeAV1,
 			ClockRate: 90000,
 		},
 		PayloadType: 96,
-				},
+	}},
-				webrtc.RTPCodecTypeVideo)
+	"vp9": {
-			if err != nil {
+		{
-				return nil, err
-			}
-
-		case "vp9":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 			RTPCodecCapability: webrtc.RTPCodecCapability{
 				MimeType:    webrtc.MimeTypeVP9,
 				ClockRate:   90000,
@@ -74,13 +28,7 @@ func newPeerConnection(
 			},
 			PayloadType: 96,
 		},
-				webrtc.RTPCodecTypeVideo)
+		{
-			if err != nil {
-				return nil, err
-			}
-
-			err = mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 			RTPCodecCapability: webrtc.RTPCodecCapability{
 				MimeType:    webrtc.MimeTypeVP9,
 				ClockRate:   90000,
@@ -88,45 +36,26 @@ func newPeerConnection(
 			},
 			PayloadType: 96,
 		},
-				webrtc.RTPCodecTypeVideo)
+	},
-			if err != nil {
+	"vp8": {{
-				return nil, err
-			}
-
-		case "vp8":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:  webrtc.MimeTypeVP8,
 			ClockRate: 90000,
 		},
 		PayloadType: 96,
-				},
+	}},
-				webrtc.RTPCodecTypeVideo)
+	"h264": {{
-			if err != nil {
-				return nil, err
-			}
-
-		case "h264":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:    webrtc.MimeTypeH264,
 			ClockRate:   90000,
 			SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
 		},
 		PayloadType: 96,
-				},
+	}},
-				webrtc.RTPCodecTypeVideo)
-			if err != nil {
-				return nil, err
-			}
 }
 
-		switch audioCodec {
+var audioCodecs = map[string][]webrtc.RTPCodecParameters{
-		case "opus":
+	"opus": {{
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:    webrtc.MimeTypeOpus,
 			ClockRate:   48000,
@@ -134,73 +63,106 @@ func newPeerConnection(
 			SDPFmtpLine: "minptime=10;useinbandfec=1",
 		},
 		PayloadType: 111,
-				},
+	}},
-				webrtc.RTPCodecTypeAudio)
+	"g722": {{
-			if err != nil {
-				return nil, err
-			}
-
-		case "g722":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:  webrtc.MimeTypeG722,
 			ClockRate: 8000,
 		},
 		PayloadType: 9,
-				},
+	}},
-				webrtc.RTPCodecTypeAudio)
+	"pcmu": {{
-			if err != nil {
-				return nil, err
-			}
-
-		case "pcmu":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:  webrtc.MimeTypePCMU,
 			ClockRate: 8000,
 		},
 		PayloadType: 0,
-				},
+	}},
-				webrtc.RTPCodecTypeAudio)
+	"pcma": {{
-			if err != nil {
-				return nil, err
-			}
-
-		case "pcma":
-			err := mediaEngine.RegisterCodec(
-				webrtc.RTPCodecParameters{
 		RTPCodecCapability: webrtc.RTPCodecCapability{
 			MimeType:  webrtc.MimeTypePCMA,
 			ClockRate: 8000,
 		},
 		PayloadType: 8,
-				},
+	}},
-				webrtc.RTPCodecTypeAudio)
+}
+
+type peerConnection struct {
+	*webrtc.PeerConnection
+	stateChangeMutex   sync.Mutex
+	localCandidateRecv chan *webrtc.ICECandidateInit
+	connected          chan struct{}
+	disconnected       chan struct{}
+	closed             chan struct{}
+	gatheringDone      chan struct{}
+}
+
+func newPeerConnection(
+	videoCodec string,
+	audioCodec string,
+	iceServers []webrtc.ICEServer,
+	iceHostNAT1To1IPs []string,
+	iceUDPMux ice.UDPMux,
+	iceTCPMux ice.TCPMux,
+	log logger.Writer,
+) (*peerConnection, error) {
+	configuration := webrtc.Configuration{ICEServers: iceServers}
+	settingsEngine := webrtc.SettingEngine{}
+
+	if len(iceHostNAT1To1IPs) != 0 {
+		settingsEngine.SetNAT1To1IPs(iceHostNAT1To1IPs, webrtc.ICECandidateTypeHost)
+	}
+
+	if iceUDPMux != nil {
+		settingsEngine.SetICEUDPMux(iceUDPMux)
+	}
+
+	if iceTCPMux != nil {
+		settingsEngine.SetICETCPMux(iceTCPMux)
+		settingsEngine.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeTCP4})
+	}
+
+	mediaEngine := &webrtc.MediaEngine{}
+
+	if videoCodec != "" || audioCodec != "" {
+		codec, ok := videoCodecs[videoCodec]
+		if ok {
+			for _, params := range codec {
+				err := mediaEngine.RegisterCodec(params, webrtc.RTPCodecTypeVideo)
 				if err != nil {
 					return nil, err
 				}
 			}
-	} else {
+		}
-		// register all codecs
+
-		err := mediaEngine.RegisterDefaultCodecs()
+		codec, ok = audioCodecs[audioCodec]
+		if ok {
+			for _, params := range codec {
+				err := mediaEngine.RegisterCodec(params, webrtc.RTPCodecTypeAudio)
 				if err != nil {
 					return nil, err
 				}
-		err = mediaEngine.RegisterCodec(
+			}
-			webrtc.RTPCodecParameters{
+		}
-				RTPCodecCapability: webrtc.RTPCodecCapability{
+	} else { // register all codecs
-					MimeType:  webrtc.MimeTypeAV1,
+		for _, codec := range videoCodecs {
-					ClockRate: 90000,
+			for _, params := range codec {
-				},
+				err := mediaEngine.RegisterCodec(params, webrtc.RTPCodecTypeVideo)
-				PayloadType: 105,
-			},
-			webrtc.RTPCodecTypeVideo)
 				if err != nil {
 					return nil, err
 				}
 			}
+		}
+
+		for _, codec := range audioCodecs {
+			for _, params := range codec {
+				err := mediaEngine.RegisterCodec(params, webrtc.RTPCodecTypeAudio)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
 
 	interceptorRegistry := &interceptor.Registry{}
 	if err := webrtc.RegisterDefaultInterceptors(mediaEngine, interceptorRegistry); err != nil {

internal/core/webrtc_publish_index.html

@@ -72,6 +72,9 @@ select {
         <div id="bitrate_line">
             video bitrate (kbps):
             <input id="video_bitrate" type="text" value="10000" />
+
+            audio bitrate (kbps):
+            <input id="audio_bitrate" type="text" value="32" />
         </div>
         <div id="submit_line">
             <button id="publish_confirm">publish</button>
@@ -222,11 +225,13 @@ class Transmitter {
                 const videoCodec = document.getElementById('video_codec').value;
                 const audioCodec = document.getElementById('audio_codec').value;
                 const videoBitrate = document.getElementById('video_bitrate').value;
+                const audioBitrate = document.getElementById('audio_bitrate').value;
 
                 const p = new URLSearchParams(window.location.search);
                 p.set('video_codec', videoCodec);
                 p.set('audio_codec', audioCodec);
                 p.set('video_bitrate', videoBitrate);
+                p.set('audio_bitrate', audioBitrate);
 
                 fetch(new URL('whip', window.location.href) + '?' + p.toString(), {
                     method: 'POST',

internal/core/webrtc_session.go

@@ -48,28 +48,76 @@ func mediasOfIncomingTracks(tracks []*webRTCIncomingTrack) media.Medias {
 	return ret
 }
 
-func insertTias(offer *webrtc.SessionDescription, value uint64) {
+func findOpusPayloadFormat(attributes []sdp.Attribute) int {
+	for _, attr := range attributes {
+		if attr.Key == "rtpmap" && strings.Contains(attr.Value, "opus/") {
+			parts := strings.SplitN(attr.Value, " ", 2)
+			pl, err := strconv.ParseUint(parts[0], 10, 31)
+			if err == nil {
+				return int(pl)
+			}
+		}
+	}
+	return 0
+}
+
+func editAnswer(offer *webrtc.SessionDescription, videoBitrateStr string, audioBitrateStr string) error {
 	var sd sdp.SessionDescription
 	err := sd.Unmarshal([]byte(offer.SDP))
 	if err != nil {
-		return
+		return err
+	}
+
+	if videoBitrateStr != "" {
+		videoBitrate, err := strconv.ParseUint(videoBitrateStr, 10, 31)
+		if err != nil {
+			return err
 		}
 
 		for _, media := range sd.MediaDescriptions {
 			if media.MediaName.Media == "video" {
 				media.Bandwidth = []sdp.Bandwidth{{
 					Type:      "TIAS",
-				Bandwidth: value,
+					Bandwidth: videoBitrate * 1024,
 				}}
+				break
+			}
+		}
+	}
+
+	if audioBitrateStr != "" {
+		audioBitrate, err := strconv.ParseUint(audioBitrateStr, 10, 31)
+		if err != nil {
+			return err
+		}
+
+		for _, media := range sd.MediaDescriptions {
+			if media.MediaName.Media == "audio" {
+				pl := findOpusPayloadFormat(media.Attributes)
+				if pl != 0 {
+					for i, attr := range media.Attributes {
+						if attr.Key == "fmtp" && strings.HasPrefix(attr.Value, strconv.FormatInt(int64(pl), 10)+" ") {
+							media.Attributes[i] = sdp.Attribute{
+								Key: "fmtp",
+								Value: strconv.FormatInt(int64(pl), 10) + " stereo=1;sprop-stereo=1;maxaveragebitrate=" +
+									strconv.FormatUint(audioBitrate*1024, 10),
+							}
+						}
+					}
+				}
+
+				break
+			}
 		}
 	}
 
 	enc, err := sd.Marshal()
 	if err != nil {
-		return
+		return err
 	}
 
 	offer.SDP = string(enc)
+	return nil
 }
 
 func gatherOutgoingTracks(medias media.Medias) ([]*webRTCOutgoingTrack, error) {
@@ -320,15 +368,11 @@ func (s *webRTCSession) runPublish() (int, error) {
 	tmp := pc.LocalDescription()
 	answer = *tmp
 
-	if s.req.videoBitrate != "" {
+	err = editAnswer(&answer, s.req.videoBitrate, s.req.audioBitrate)
-		tmp, err := strconv.ParseUint(s.req.videoBitrate, 10, 31)
 	if err != nil {
 		return http.StatusBadRequest, err
 	}
 
-		insertTias(&answer, tmp*1024)
-	}
-
 	err = s.writeAnswer(&answer)
 	if err != nil {
 		return http.StatusBadRequest, err