fix(multi-stream) Fix VP9 bitrates in the multi-stream mode.

Set the bitrates on the video m-lines based on the associated track type. In multi-stream mode, there will be two separate m-lines for camera and desktop tracks. Also fallback to SDP munging for setting codec preferences on Chromium.

modules/RTC/TPCUtils.js

@@ -297,8 +297,8 @@ export class TPCUtils {
             // b/w and cpu cases, especially on the low end machines. Suspending the low resolution streams ensures
             // that the highest resolution stream is available always. Safari is an exception here since it does not
             // send the desktop stream at all if only the high resolution stream is enabled.
-            if (this.pc.isSharingLowFpsScreen()
-                && localVideoTrack.getVideoType() === VideoType.DESKTOP
+            if (localVideoTrack.getVideoType() === VideoType.DESKTOP
+                && this.pc._capScreenshareBitrate
                 && this.pc.usesUnifiedPlan()
                 && !browser.isWebKitBased()
                 && this.localStreamEncodingsConfig[idx].scaleResolutionDownBy !== HD_SCALE_FACTOR) {
@@ -323,10 +323,12 @@ export class TPCUtils {
         const desktopShareBitrate = this.pc.options?.videoQuality?.desktopBitrate || DESKTOP_SHARE_RATE;
         const presenterEnabled = localVideoTrack._originalStream
             && localVideoTrack._originalStream.id !== localVideoTrack.getStreamId();
-
+        const lowFpsScreenshare = localVideoTrack.getVideoType() === VideoType.DESKTOP
+            && this.pc._capScreenshareBitrate
+            && !browser.isWebKitBased();
         const encodingsBitrates = this.localStreamEncodingsConfig
         .map(encoding => {
-            const bitrate = this.pc.isSharingLowFpsScreen() && !browser.isWebKitBased()
+            const bitrate = lowFpsScreenshare
 
                 // For low fps screensharing, set a max bitrate of 500 Kbps when presenter is not turned on, 2500 Kbps
                 // otherwise.

modules/RTC/TraceablePeerConnection.js

@@ -1639,28 +1639,6 @@ TraceablePeerConnection.prototype._mungeCodecOrder = function(description) {
         if (this.codecPreference.mimeType === CodecMimeType.H264 && browser.isReactNative() && this.isP2P) {
             SDPUtil.stripCodec(mLine, this.codecPreference.mimeType, true /* high profile */);
         }
-
-        // Set the max bitrate here on the SDP so that the configured max. bitrate is effective
-        // as soon as the browser switches to VP9.
-        if (this.codecPreference.mimeType === CodecMimeType.VP9
-            && this.getConfiguredVideoCodec() === CodecMimeType.VP9) {
-            const bitrates = this.tpcUtils.videoBitrates.VP9 || this.tpcUtils.videoBitrates;
-            const hdBitrate = bitrates.high ? bitrates.high : HD_BITRATE;
-            const limit = Math.floor((this._isSharingScreen() ? HD_BITRATE : hdBitrate) / 1000);
-
-            // Use only the HD bitrate for now as there is no API available yet for configuring
-            // the bitrates on the individual SVC layers.
-            mLine.bandwidth = [ {
-                type: 'AS',
-                limit
-            } ];
-        } else {
-            // Clear the bandwidth limit in SDP when VP9 is no longer the preferred codec.
-            // This is needed on react native clients as react-native-webrtc returns the
-            // SDP that the application passed instead of returning the SDP off the native side.
-            // This line automatically gets cleared on web on every renegotiation.
-            mLine.bandwidth = undefined;
-        }
     } else {
         SDPUtil.stripCodec(mLine, this.codecPreference.mimeType);
     }
@@ -2344,6 +2322,74 @@ TraceablePeerConnection.prototype._initializeDtlsTransport = function() {
     }
 };
 
+/**
+ * Sets the max bitrates on the video m-lines when VP9 is the selected codec.
+ *
+ * @param {RTCSessionDescription} description - The local description that needs to be munged.
+ * @returns RTCSessionDescription
+ */
+TraceablePeerConnection.prototype._setVp9MaxBitrates = function(description) {
+    if (!this.codecPreference) {
+        return description;
+    }
+
+    const parsedSdp = transform.parse(description.sdp);
+    const mLines = FeatureFlags.isMultiStreamSupportEnabled()
+        ? parsedSdp.media.filter(m => m.type === MediaType.VIDEO && m.direction !== MediaDirection.RECVONLY)
+        : [ parsedSdp.media.find(m => m.type === MediaType.VIDEO) ];
+
+    // Find the mid associated with the desktop track so that bitrates can be configured accordingly on the
+    // corresponding m-line.
+    const getDesktopTrackMid = () => {
+        const desktopTrack = this.getLocalVideoTracks().find(track => track.getVideoType() === VideoType.DESKTOP);
+        let mid;
+
+        if (desktopTrack) {
+            const trackIndex = Number(desktopTrack.getSourceName()?.split('-')[1].substring(1));
+
+            if (typeof trackIndex === 'number') {
+                const transceiver = this.peerconnection.getTransceivers()
+                    .filter(t => t.receiver.track.kind === MediaType.VIDEO
+                        && t.direction !== MediaDirection.RECVONLY)[trackIndex];
+
+                mid = transceiver?.mid;
+            }
+        }
+
+        return Number(mid);
+    };
+
+    for (const mLine of mLines) {
+        if (this.codecPreference.mimeType === CodecMimeType.VP9
+            && this.getConfiguredVideoCodec() === CodecMimeType.VP9) {
+            const bitrates = this.tpcUtils.videoBitrates.VP9 || this.tpcUtils.videoBitrates;
+            const hdBitrate = bitrates.high ? bitrates.high : HD_BITRATE;
+            const mid = mLine.mid;
+            const isSharingScreen = FeatureFlags.isMultiStreamSupportEnabled()
+                ? mid === getDesktopTrackMid()
+                : this._isSharingScreen();
+            const limit = Math.floor((isSharingScreen ? HD_BITRATE : hdBitrate) / 1000);
+
+            // Use only the HD bitrate for now as there is no API available yet for configuring
+            // the bitrates on the individual SVC layers.
+            mLine.bandwidth = [ {
+                type: 'AS',
+                limit
+            } ];
+        } else {
+            // Clear the bandwidth limit in SDP when VP9 is no longer the preferred codec.
+            // This is needed on react native clients as react-native-webrtc returns the
+            // SDP that the application passed instead of returning the SDP off the native side.
+            // This line automatically gets cleared on web on every renegotiation.
+            mLine.bandwidth = undefined;
+        }
+    }
+
+    return new RTCSessionDescription({
+        type: description.type,
+        sdp: transform.write(parsedSdp)
+    });
+};
 
 /**
  * Configures the stream encodings depending on the video type and the bitrates configured.
@@ -2389,10 +2435,9 @@ TraceablePeerConnection.prototype.setLocalDescription = function(description) {
         localDescription = this._ensureSimulcastGroupIsLast(localDescription);
     }
 
-    // Munge the order of the codecs based on the preferences set through config.js if we are using SDP munging.
-    if (!this._usesTransceiverCodecPreferences) {
-        localDescription = this._mungeCodecOrder(localDescription);
-    }
+    // Munge the order of the codecs based on the preferences set through config.js.
+    localDescription = this._mungeCodecOrder(localDescription);
+    localDescription = this._setVp9MaxBitrates(localDescription);
 
     this.trace('setLocalDescription::postTransform', dumpSDP(localDescription));
 
@@ -2549,8 +2594,10 @@ TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeig
         return Promise.resolve();
     }
 
+    const isSharingLowFpsScreen = localVideoTrack.getVideoType() === VideoType.DESKTOP && this._capScreenshareBitrate;
+
     // Set the degradation preference.
-    const preference = this.isSharingLowFpsScreen()
+    const preference = isSharingLowFpsScreen
         ? DEGRADATION_PREFERENCE_DESKTOP // Prefer resolution for low fps share.
         : DEGRADATION_PREFERENCE_CAMERA; // Prefer frame-rate for high fps share and camera.
 
@@ -2571,10 +2618,9 @@ TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeig
                 // encodings.
                 browser.isFirefox() && (parameters.encodings[encoding].degradationPreference = preference);
 
-                // Max bitrates are configured on the encodings only for VP8.
                 if (this.getConfiguredVideoCodec() === CodecMimeType.VP8
                     && (this.options?.videoQuality?.maxBitratesVideo
-                        || this.isSharingLowFpsScreen()
+                        || isSharingLowFpsScreen
                         || this._usesUnifiedPlan)) {
                     parameters.encodings[encoding].maxBitrate = maxBitrates[encoding];
                 }
@@ -2820,8 +2866,7 @@ TraceablePeerConnection.prototype._createOfferOrAnswer = function(
             // Configure simulcast for camera tracks and for desktop tracks that need simulcast.
             if (this.isSimulcastOn() && browser.usesSdpMungingForSimulcast()
                 && (localVideoTrack?.getVideoType() === VideoType.CAMERA
-                || this._usesUnifiedPlan
-                || !this.isSharingLowFpsScreen())) {
+                || this._usesUnifiedPlan)) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.simulcast.mungeLocalDescription(resultSdp);
                 this.trace(`create${logName} OnSuccess::postTransform (simulcast)`, dumpSDP(resultSdp));

types/auto/modules/RTC/TraceablePeerConnection.d.ts

@@ -646,6 +646,13 @@ export default class TraceablePeerConnection {
      * Sets up the _dtlsTransport object and initializes callbacks for it.
      */
     _initializeDtlsTransport(): void;
+    /**
+     * Sets the max bitrates on the video m-lines when VP9 is the selected codec.
+     *
+     * @param {RTCSessionDescription} description - The local description that needs to be munged.
+     * @returns RTCSessionDescription
+     */
+    _setVp9MaxBitrates(description: RTCSessionDescription): RTCSessionDescription;
     /**
      * Configures the stream encodings depending on the video type and the bitrates configured.
      *