ref(TPC) Configure encodings in one go. (#1739)

* ref(TPC) Configure encodings in one go.
Configure the active state, maxBitrate and degradation preference in one go instead of configuring them separately.

* squash: Address review comments.

* squash: fix a comment.

modules/RTC/MockClasses.js

@@ -66,9 +66,9 @@ export class MockPeerConnection {
     }
 
     /**
-     * {@link TraceablePeerConnection.setSenderVideoConstraint}.
+     * {@link TraceablePeerConnection.setSenderVideoConstraints}.
      */
-    setSenderVideoConstraint() {
+    setSenderVideoConstraints() {
     }
 
     /**

modules/RTC/TPCUtils.js

@@ -3,13 +3,21 @@ import transform from 'sdp-transform';
 
 import MediaDirection from '../../service/RTC/MediaDirection';
 import * as MediaType from '../../service/RTC/MediaType';
+import VideoType from '../../service/RTC/VideoType';
 import browser from '../browser';
 
 const logger = getLogger(__filename);
+const DESKTOP_SHARE_RATE = 500000;
+const LD_BITRATE = 200000;
+const SD_BITRATE = 700000;
 const SIM_LAYER_1_RID = '1';
 const SIM_LAYER_2_RID = '2';
 const SIM_LAYER_3_RID = '3';
 
+export const HD_BITRATE = 2500000;
+export const HD_SCALE_FACTOR = 1;
+export const LD_SCALE_FACTOR = 4;
+export const SD_SCALE_FACTOR = 2;
 export const SIM_LAYER_RIDS = [ SIM_LAYER_1_RID, SIM_LAYER_2_RID, SIM_LAYER_3_RID ];
 
 /**
@@ -21,12 +29,21 @@ export class TPCUtils {
      * Creates a new instance for a given TraceablePeerConnection
      *
      * @param peerconnection - the tpc instance for which we have utility functions.
-     * @param videoBitrates - the bitrates to be configured on the video senders for
-     * different resolutions both in unicast and simulcast mode.
      */
-    constructor(peerconnection, videoBitrates) {
+    constructor(peerconnection) {
         this.pc = peerconnection;
-        this.videoBitrates = videoBitrates.VP8 || videoBitrates;
+        const bitrateSettings = this.pc.options?.videoQuality?.maxBitratesVideo;
+        const standardBitrates = {
+            low: LD_BITRATE,
+            standard: SD_BITRATE,
+            high: HD_BITRATE
+        };
+
+        // Check if the max. bitrates for video are specified through config.js videoQuality settings.
+        // Right now only VP8 bitrates are configured on the simulcast encodings, VP9 bitrates have to be
+        // configured on the SDP using b:AS line.
+        this.videoBitrates = bitrateSettings ?? standardBitrates;
+        const encodingBitrates = this.videoBitrates.VP8 ?? this.videoBitrates;
 
         /**
          * The startup configuration for the stream encodings that are applicable to
@@ -44,21 +61,21 @@ export class TPCUtils {
         this.localStreamEncodingsConfig = [
             {
                 active: true,
-                maxBitrate: browser.isFirefox() ? this.videoBitrates.high : this.videoBitrates.low,
+                maxBitrate: browser.isFirefox() ? encodingBitrates.high : encodingBitrates.low,
                 rid: SIM_LAYER_1_RID,
-                scaleResolutionDownBy: browser.isFirefox() ? 1.0 : 4.0
+                scaleResolutionDownBy: browser.isFirefox() ? HD_SCALE_FACTOR : LD_SCALE_FACTOR
             },
             {
                 active: true,
-                maxBitrate: this.videoBitrates.standard,
+                maxBitrate: encodingBitrates.standard,
                 rid: SIM_LAYER_2_RID,
-                scaleResolutionDownBy: 2.0
+                scaleResolutionDownBy: SD_SCALE_FACTOR
             },
             {
                 active: true,
-                maxBitrate: browser.isFirefox() ? this.videoBitrates.low : this.videoBitrates.high,
+                maxBitrate: browser.isFirefox() ? encodingBitrates.low : encodingBitrates.high,
                 rid: SIM_LAYER_3_RID,
-                scaleResolutionDownBy: browser.isFirefox() ? 4.0 : 1.0
+                scaleResolutionDownBy: browser.isFirefox() ? LD_SCALE_FACTOR : HD_SCALE_FACTOR
             }
         ];
     }
@@ -273,29 +290,82 @@ export class TPCUtils {
     }
 
     /**
-     * Obtains the current local video track's height constraints based on the
-     * initial stream encodings configuration on the sender and the resolution
-     * of the current local track added to the peerconnection.
-     * @param {MediaStreamTrack} localTrack local video track
-     * @returns {Array[number]} an array containing the resolution heights of
-     * simulcast streams configured on the video sender.
+     * Returns the calculated active state of the simulcast encodings based on the frame height requested for the send
+     * stream. All the encodings that have a resolution lower than the frame height requested will be enabled.
+     *
+     * @param {JitsiLocalTrack} localVideoTrack The local video track.
+     * @param {number} newHeight The resolution requested for the video track.
+     * @returns {Array<boolean>}
      */
-    getLocalStreamHeightConstraints(localTrack) {
-        // React-native hasn't implemented MediaStreamTrack getSettings yet.
-        if (browser.isReactNative()) {
-            return null;
-        }
+    calculateEncodingsActiveState(localVideoTrack, newHeight) {
+        const localTrack = localVideoTrack.getTrack();
+        const { height } = localTrack.getSettings();
+        const encodingsState = this.localStreamEncodingsConfig
+        .map(encoding => height / encoding.scaleResolutionDownBy)
+        .map((frameHeight, idx) => {
+            let active = localVideoTrack.getVideoType() === VideoType.CAMERA
+
+                // Keep the LD stream enabled even when the LD stream's resolution is higher than of the requested
+                // resolution. This can happen when camera is captured at resolutions higher than 720p but the
+                // requested resolution is 180. Since getParameters doesn't give us information about the resolutions
+                // of the simulcast encodings, we have to rely on our initial config for the simulcast streams.
+                ? newHeight > 0 && this.localStreamEncodingsConfig[idx]?.scaleResolutionDownBy === LD_SCALE_FACTOR
+                    ? true
+                    : frameHeight <= newHeight
+
+                // Keep all the encodings for desktop track active.
+                : true;
+
+            // Disable the lower spatial layers for screensharing in Unified plan when low fps screensharing is in
+            // progress. Sending all three streams often results in the browser suspending the high resolution in low
+            // 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()
+                && this.pc.usesUnifiedPlan()
+                && !browser.isWebKitBased()
+                && this.localStreamEncodingsConfig[idx].scaleResolutionDownBy !== HD_SCALE_FACTOR) {
+                active = false;
+            }
 
-        const localVideoHeightConstraints = [];
+            return active;
+        });
 
-        // Firefox doesn't return the height of the desktop track, assume a min. height of 720.
-        const { height = 720 } = localTrack.getSettings();
+        return encodingsState;
+    }
 
-        for (const encoding of this.localStreamEncodingsConfig) {
-            localVideoHeightConstraints.push(height / encoding.scaleResolutionDownBy);
-        }
+    /**
+     * Returns the calculates max bitrates that need to be configured on the simulcast encodings based on the video
+     * type and other considerations associated with screenshare.
+     *
+     * @param {JitsiLocalTrack} localVideoTrack The local video track.
+     * @returns {Array<number>}
+     */
+    calculateEncodingsBitrates(localVideoTrack) {
+        const videoType = localVideoTrack.getVideoType();
+        const desktopShareBitrate = this.pc.options?.videoQuality?.desktopBitrate || DESKTOP_SHARE_RATE;
+        const presenterEnabled = localVideoTrack._originalStream
+            && localVideoTrack._originalStream.id !== localVideoTrack.getStreamId();
+
+        const encodingsBitrates = this.localStreamEncodingsConfig
+        .map(encoding => {
+            const bitrate = this.pc.isSharingLowFpsScreen() && !browser.isWebKitBased()
+
+                // For low fps screensharing, set a max bitrate of 500 Kbps when presenter is not turned on, 2500 Kbps
+                // otherwise.
+                ? presenterEnabled ? HD_BITRATE : desktopShareBitrate
+
+                // For high fps screenshare, 'maxBitrate' setting must be cleared on Chrome in plan-b, because
+                // if simulcast is enabled for screen and maxBitrates are set then Chrome will not send the
+                // desktop stream.
+                : videoType === VideoType.DESKTOP && browser.isChromiumBased() && !this.pc.usesUnifiedPlan()
+                    ? undefined
+                    : encoding.maxBitrate;
+
+            return bitrate;
+        });
 
-        return localVideoHeightConstraints;
+        return encodingsBitrates;
     }
 
     /**

modules/RTC/TraceablePeerConnection.js

@@ -23,17 +23,18 @@ import * as GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import RTC from './RTC';
 import RTCUtils from './RTCUtils';
-import { SIM_LAYER_RIDS, TPCUtils } from './TPCUtils';
+import {
+    HD_BITRATE,
+    HD_SCALE_FACTOR,
+    SIM_LAYER_RIDS,
+    TPCUtils
+} from './TPCUtils';
 
 // FIXME SDP tools should end up in some kind of util module
 
 const logger = getLogger(__filename);
 const DEGRADATION_PREFERENCE_CAMERA = 'maintain-framerate';
 const DEGRADATION_PREFERENCE_DESKTOP = 'maintain-resolution';
-const DESKTOP_SHARE_RATE = 500000;
-const HD_BITRATE = 2500000;
-const LD_BITRATE = 200000;
-const SD_BITRATE = 700000;
 
 /* eslint-disable max-params */
 
@@ -224,21 +225,7 @@ export default function TraceablePeerConnection(
 
     this.peerconnection = new RTCUtils.RTCPeerConnectionType(pcConfig, safeConstraints);
 
-    // The standard video bitrates are used in Unified plan when switching
-    // between camera/desktop tracks on the same sender.
-    const standardVideoBitrates = {
-        low: LD_BITRATE,
-        standard: SD_BITRATE,
-        high: HD_BITRATE
-    };
-
-    // Check if the max. bitrates for video are specified through config.js videoQuality settings.
-    // These bitrates will be applied on all browsers for camera sources in both simulcast and p2p mode.
-    this.videoBitrates = this.options.videoQuality && this.options.videoQuality.maxBitratesVideo
-        ? this.options.videoQuality.maxBitratesVideo
-        : standardVideoBitrates;
-
-    this.tpcUtils = new TPCUtils(this, this.videoBitrates);
+    this.tpcUtils = new TPCUtils(this);
     this.updateLog = [];
     this.stats = {};
     this.statsinterval = null;
@@ -293,9 +280,10 @@ export default function TraceablePeerConnection(
     this.rtxModifier = new RtxModifier();
 
     /**
-     * The height constraint applied on the video sender.
+     * The height constraint applied on the video sender. The default value is 2160 (4K) when layer suspension is
+     * explicitly disabled.
      */
-    this.senderVideoMaxHeight = null;
+    this._senderVideoMaxHeight = 2160;
 
     // override as desired
     this.trace = (what, info) => {
@@ -724,7 +712,7 @@ TraceablePeerConnection.prototype.getRemoteSourceInfoByParticipant = function(id
 TraceablePeerConnection.prototype.getTargetVideoBitrates = function() {
     const currentCodec = this.getConfiguredVideoCodec();
 
-    return this.videoBitrates[currentCodec.toUpperCase()] || this.videoBitrates;
+    return this.tpcUtils.videoBitrates[currentCodec.toUpperCase()] || this.tpcUtils.videoBitrates;
 };
 
 /**
@@ -1593,7 +1581,7 @@ TraceablePeerConnection.prototype._getSSRC = function(rtcId) {
  * @private
  * @returns {boolean} Returns true if 5 fps screensharing is in progress, false otherwise.
  */
-TraceablePeerConnection.prototype._isSharingLowFpsScreen = function() {
+TraceablePeerConnection.prototype.isSharingLowFpsScreen = function() {
     return this._isSharingScreen() && this._capScreenshareBitrate;
 };
 
@@ -1649,7 +1637,7 @@ TraceablePeerConnection.prototype._mungeCodecOrder = function(description) {
         // as soon as the browser switches to VP9.
         if (this.codecPreference.mimeType === CodecMimeType.VP9
             && this.getConfiguredVideoCodec() === CodecMimeType.VP9) {
-            const bitrates = this.videoBitrates.VP9 || this.videoBitrates;
+            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);
 
@@ -2243,6 +2231,15 @@ TraceablePeerConnection.prototype._mungeOpus = function(description) {
     });
 };
 
+/**
+ * Configures the stream encodings depending on the video type and the bitrates configured.
+ *
+ * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
+ */
+TraceablePeerConnection.prototype.configureSenderVideoEncodings = function() {
+    return this.setSenderVideoConstraints(this._senderVideoMaxHeight);
+};
+
 TraceablePeerConnection.prototype.setLocalDescription = function(description) {
     let localSdp = description;
 
@@ -2319,131 +2316,6 @@ TraceablePeerConnection.prototype.setAudioTransferActive = function(active) {
     return changed;
 };
 
-/**
- * Sets the degradation preference on the video sender. This setting determines if
- * resolution or framerate will be preferred when bandwidth or cpu is constrained.
- * Sets it to 'maintain-framerate' when a camera track is added to the pc, sets it
- * to 'maintain-resolution' when a desktop track is being shared instead.
- * @returns {Promise<void>}
- */
-TraceablePeerConnection.prototype.setSenderVideoDegradationPreference = function() {
-    if (!this.peerconnection.getSenders) {
-        logger.debug(`${this} Browser does not support RTCRtpSender`);
-
-        return Promise.resolve();
-    }
-    const localVideoTrack = this.getLocalVideoTrack();
-    const videoSender = this.findSenderByKind(MediaType.VIDEO);
-
-    if (!videoSender) {
-        return Promise.resolve();
-    }
-    const parameters = videoSender.getParameters();
-    const preference = this._isSharingLowFpsScreen()
-
-        // Prefer resolution for low fps share.
-        ? DEGRADATION_PREFERENCE_DESKTOP
-
-        // Prefer frame-rate for high fps share and camera.
-        : DEGRADATION_PREFERENCE_CAMERA;
-
-    logger.info(`${this} Setting a degradation preference [preference=${preference},track=${localVideoTrack}`);
-    parameters.degradationPreference = preference;
-    this.tpcUtils.updateEncodingsResolution(parameters);
-
-    return videoSender.setParameters(parameters);
-};
-
-/**
- * Sets the max bitrate on the RTCRtpSender so that the
- * bitrate of the enocder doesn't exceed the configured value.
- * This is needed for the desktop share until spec-complaint
- * simulcast is implemented.
- * @param {JitsiLocalTrack} localTrack - the local track whose
- * max bitrate is to be configured.
- * @returns {Promise<void>}
- */
-TraceablePeerConnection.prototype.setMaxBitRate = function() {
-    // For VP9, max bitrate is configured by setting b=AS value in SDP. Browsers do
-    // not yet support setting max bitrates for individual VP9 SVC layers.
-    if (this.getConfiguredVideoCodec() === CodecMimeType.VP9 || !window.RTCRtpSender) {
-        return Promise.resolve();
-    }
-    const localVideoTrack = this.getLocalVideoTrack();
-
-    if (!localVideoTrack) {
-        return Promise.resolve();
-    }
-
-    const videoType = localVideoTrack.getVideoType();
-
-    // Apply the maxbitrates on the video track when one of the conditions is met.
-    // 1. Max. bitrates for video are specified through videoQuality settings in config.js
-    // 2. Track is a low fps desktop track.
-    // 3. The client is running in Unified plan mode (the same sender is re-used for different types
-    // of tracks so bitrates have to be configured whenever the local tracks are replaced).
-    if (!(this.options?.videoQuality?.maxBitratesVideo || this._isSharingLowFpsScreen() || this._usesUnifiedPlan)) {
-        return Promise.resolve();
-    }
-
-    const presenterEnabled = localVideoTrack._originalStream
-        && localVideoTrack._originalStream.id !== localVideoTrack.getStreamId();
-    const videoSender = this.findSenderByKind(MediaType.VIDEO);
-
-    if (!videoSender) {
-        return Promise.resolve();
-    }
-    const parameters = videoSender.getParameters();
-
-    if (!parameters.encodings?.length) {
-        return Promise.resolve();
-    }
-
-    if (this.isSimulcastOn()) {
-        for (const encoding in parameters.encodings) {
-            if (parameters.encodings.hasOwnProperty(encoding)) {
-                const bitrate = this._isSharingLowFpsScreen()
-
-                    // For low fps screensharing, set a max bitrate of 500 Kbps when presenter is not turned on.
-                    // FIXME the top 'isSimulcastOn' condition is confusing for screensharing, because
-                    // if capScreenshareBitrate option is enabled then simulcast is turned off for the stream.
-                    ? presenterEnabled ? HD_BITRATE : DESKTOP_SHARE_RATE
-
-                    // For high fps screenshare, 'maxBitrate' setting must be cleared on Chrome, because if simulcast is
-                    // enabled for screen and maxBitrates are set then Chrome will not send the desktop stream.
-                    : videoType === VideoType.DESKTOP && browser.isChromiumBased()
-                        ? undefined
-                        : this.tpcUtils.localStreamEncodingsConfig[encoding].maxBitrate;
-
-                logger.info(`${this} Setting a max bitrate of ${bitrate} bps on layer `
-                    + `${this.tpcUtils.localStreamEncodingsConfig[encoding].rid}`);
-                parameters.encodings[encoding].maxBitrate = bitrate;
-            }
-        }
-    } else {
-        // Do not change the max bitrate for desktop tracks in non-simulcast mode.
-        let bitrate = this.getTargetVideoBitrates()?.high;
-
-        if (videoType === VideoType.CAMERA) {
-            // Determine the bitrates based on the sender constraint applied for unicast tracks.
-            const scaleFactor = this.senderVideoMaxHeight
-                ? Math.floor(localVideoTrack.resolution / this.senderVideoMaxHeight)
-                : 1;
-            const encoding = this.tpcUtils.localStreamEncodingsConfig
-                .find(layer => layer.scaleResolutionDownBy === scaleFactor);
-
-            if (encoding) {
-                logger.info(`${this} Setting max bitrate=${encoding.maxBitrate} bps on track=${localVideoTrack}`);
-                bitrate = encoding.maxBitrate;
-            }
-        }
-        parameters.encodings[0].maxBitrate = bitrate;
-    }
-    this.tpcUtils.updateEncodingsResolution(parameters);
-
-    return videoSender.setParameters(parameters);
-};
-
 TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
@@ -2519,16 +2391,14 @@ TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
 };
 
 /**
- * Changes the resolution of the video stream that is sent to the peer based on
- * the user preferred value. If simulcast is enabled on the peerconection, all the
- * simulcast encodings that have a resolution height lower or equal to the value
- * provided will remain active. For the non-simulcast case, video constraint is
- * applied on the track.
- * @param {number} frameHeight - The user preferred max frame height.
- * @returns {Promise} promise that will be resolved when the operation is
- * successful and rejected otherwise.
+ * Changes the resolution of the video stream that is sent to the peer based on the resolution requested by the peer
+ * and user preference, sets the degradation preference on the sender based on the video type, configures the maximum
+ * bitrates on the send stream.
+ *
+ * @param {number} frameHeight - The max frame height to be imposed on the outgoing video stream.
+ * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
-TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeight = null) {
+TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeight) {
     if (frameHeight < 0) {
         throw new Error(`Invalid frameHeight: ${frameHeight}`);
     }
@@ -2538,20 +2408,7 @@ TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeigh
         return Promise.resolve();
     }
 
-    // Need to explicitly check for null as 0 is falsy, but a valid value
-    const newHeight = frameHeight === null ? this.senderVideoMaxHeight : frameHeight;
-
-    this.senderVideoMaxHeight = newHeight;
-
-    // If layer suspension is disabled and sender constraint is not configured for the conference,
-    // resolve here so that the encodings stay enabled. This can happen in custom apps built using
-    // lib-jitsi-meet.
-    if (newHeight === null) {
-        return Promise.resolve();
-    }
-
-    logger.log(`${this} senderVideoMaxHeight: ${newHeight}`);
-
+    this._senderVideoMaxHeight = frameHeight;
     const localVideoTrack = this.getLocalVideoTrack();
 
     if (!localVideoTrack || localVideoTrack.isMuted()) {
@@ -2568,62 +2425,71 @@ TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeigh
         return Promise.resolve();
     }
 
-    if (this.isSimulcastOn()) {
-        // Determine the encodings that need to stay enabled based on the new frameHeight provided.
-        this.encodingsEnabledState = this.tpcUtils.getLocalStreamHeightConstraints(localVideoTrack.track)
-            .map(height => height <= newHeight);
-
-        // Always keep the LD stream enabled, specifically when the LD stream's resolution is higher than of the
-        // requested resolution. This can happen when camera is captured at resolutions higher than 720p but the
-        // requested resolution is 180. Since getParameters doesn't give us information about the resolutions
-        // of the simulcast encodings, we have to rely on our initial config for the simulcast streams.
-        const ldStreamIndex = this.tpcUtils.localStreamEncodingsConfig
-            .findIndex(layer => layer.scaleResolutionDownBy === 4.0);
-
-        if (newHeight > 0 && ldStreamIndex !== -1) {
-            this.encodingsEnabledState[ldStreamIndex] = true;
-        }
+    // Set the degradation preference.
+    const preference = this.isSharingLowFpsScreen()
+        ? DEGRADATION_PREFERENCE_DESKTOP // Prefer resolution for low fps share.
+        : DEGRADATION_PREFERENCE_CAMERA; // Prefer frame-rate for high fps share and camera.
 
-        // Disable the lower spatial layers for screensharing in Unified plan when low fps screensharing is in progress
-        // There is no way to enable or disable simulcast during the call since we are re-using the same sender.
-        // 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._isSharingLowFpsScreen() && this._usesUnifiedPlan && !browser.isWebKitBased()) {
-            const highResolutionEncoding = browser.isFirefox() ? 0 : this.encodingsEnabledState.length - 1;
+    parameters.degradationPreference = preference;
+    logger.info(`${this} Setting degradation preference [preference=${preference},track=${localVideoTrack}`);
 
-            this.encodingsEnabledState = this.encodingsEnabledState
-                .map((encoding, idx) => idx === highResolutionEncoding);
-        }
+    // Calculate the encodings active state based on the resolution requested by the bridge.
+    this.encodingsEnabledState = this.tpcUtils.calculateEncodingsActiveState(localVideoTrack, frameHeight);
+    const maxBitrates = this.tpcUtils.calculateEncodingsBitrates(localVideoTrack);
+    const videoType = localVideoTrack.getVideoType();
 
+    if (this.isSimulcastOn()) {
         for (const encoding in parameters.encodings) {
             if (parameters.encodings.hasOwnProperty(encoding)) {
                 parameters.encodings[encoding].active = this.encodingsEnabledState[encoding];
+
+                // Firefox doesn't follow the spec and lets application specify the degradation preference on the
+                // 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()
+                        || this._usesUnifiedPlan)) {
+                    parameters.encodings[encoding].maxBitrate = maxBitrates[encoding];
+                }
             }
         }
         this.tpcUtils.updateEncodingsResolution(parameters);
-    } else if (newHeight > 0) {
+
+    // For p2p and cases and where simulcast is explicitly disabled.
+    } else if (frameHeight > 0) {
         // Do not scale down encodings for desktop tracks for non-simulcast case.
-        parameters.encodings[0].scaleResolutionDownBy
-            = localVideoTrack.videoType === VideoType.DESKTOP || localVideoTrack.resolution <= newHeight
-                ? 1
-                : Math.floor(localVideoTrack.resolution / newHeight);
+        const scaleFactor = videoType === VideoType.DESKTOP || localVideoTrack.resolution <= frameHeight
+            ? HD_SCALE_FACTOR
+            : Math.floor(localVideoTrack.resolution / frameHeight);
+
         parameters.encodings[0].active = true;
+        parameters.encodings[0].scaleResolutionDownBy = scaleFactor;
+
+        // Firefox doesn't follow the spec and lets application specify the degradation preference on the encodings.
+        browser.isFirefox() && (parameters.encodings[0].degradationPreference = preference);
+
+        // Configure the bitrate.
+        if (this.getConfiguredVideoCodec() === CodecMimeType.VP8 && this.options?.videoQuality?.maxBitratesVideo) {
+            let bitrate = this.getTargetVideoBitrates()?.high;
+
+            if (videoType === VideoType.CAMERA) {
+                bitrate = this.tpcUtils.localStreamEncodingsConfig
+                    .find(layer => layer.scaleResolutionDownBy === scaleFactor)?.maxBitrate ?? bitrate;
+            }
+            parameters.encodings[0].maxBitrate = bitrate;
+        }
     } else {
-        parameters.encodings[0].scaleResolutionDownBy = undefined;
         parameters.encodings[0].active = false;
     }
 
-    logger.info(`${this} setting max height=${newHeight},encodings=${JSON.stringify(parameters.encodings)}`);
+    logger.info(`${this} setting max height=${frameHeight},encodings=${JSON.stringify(parameters.encodings)}`);
 
     return videoSender.setParameters(parameters).then(() => {
-        localVideoTrack.maxEnabledResolution = newHeight;
+        localVideoTrack.maxEnabledResolution = frameHeight;
         this.eventEmitter.emit(RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED, localVideoTrack);
-
-        // Max bitrate needs to be reconfigured on the sender in p2p/non-simulcast case if needed when
-        // the send resolution changes.
-        if (this.isP2P || !this.isSimulcastOn()) {
-            return this.setMaxBitRate();
-        }
     });
 };
 
@@ -2827,7 +2693,7 @@ TraceablePeerConnection.prototype._createOfferOrAnswer = function(
             if (this.isSimulcastOn() && browser.usesSdpMungingForSimulcast()
                 && (localVideoTrack?.getVideoType() === VideoType.CAMERA
                 || this._usesUnifiedPlan
-                || !this._isSharingLowFpsScreen())) {
+                || !this.isSharingLowFpsScreen())) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.simulcast.mungeLocalDescription(resultSdp);
                 this.trace(
@@ -3029,7 +2895,7 @@ TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function(track) {
 
     // Configure simulcast for camera tracks and desktop tracks that need simulcast.
     if (this.isSimulcastOn()
-        && (track.getVideoType() === VideoType.CAMERA || !this._isSharingLowFpsScreen())) {
+        && (track.getVideoType() === VideoType.CAMERA || !this.isSharingLowFpsScreen())) {
         ssrcInfo = {
             ssrcs: [],
             groups: []

modules/qualitycontrol/SendVideoController.js

@@ -54,12 +54,6 @@ export class SendVideoController {
                     this._propagateSendMaxFrameHeight();
                 }
             });
-
-        // Set the degradation preference on the local video track.
-        mediaSession.setSenderVideoDegradationPreference();
-
-        // Set the max bitrates on video sender if they are specified in config.js videoQuality settings.
-        mediaSession.setSenderMaxBitrates();
     }
 
     /**

modules/qualitycontrol/SendVideoController.spec.js

@@ -24,16 +24,6 @@ class MockJingleSessionPC extends Listenable {
         return this._remoteRecvMaxFrameHeight;
     }
 
-    // eslint-disable-next-line no-empty-function
-    setSenderVideoDegradationPreference() {
-
-    }
-
-    // eslint-disable-next-line no-empty-function
-    setSenderMaxBitrates() {
-
-    }
-
     setSenderVideoConstraint(senderVideoConstraint) {
         this.senderVideoConstraint = senderVideoConstraint;
     }

modules/xmpp/JingleSessionPC.js

@@ -1476,20 +1476,6 @@ export default class JingleSessionPC extends JingleSession {
             IQ_TIMEOUT);
     }
 
-    /**
-     * Sets the maximum bitrates on the local video track. Bitrate values from
-     * videoQuality settings in config.js will be used for configuring the sender.
-     * @returns {Promise<void>} promise that will be resolved when the operation is
-     * successful and rejected otherwise.
-     */
-    setSenderMaxBitrates() {
-        if (this._assertNotEnded()) {
-            return this.peerconnection.setMaxBitRate();
-        }
-
-        return Promise.resolve();
-    }
-
     /**
      * Sets the resolution constraint on the local camera track.
      * @param {number} maxFrameHeight - The user preferred max frame height.
@@ -1508,21 +1494,11 @@ export default class JingleSessionPC extends JingleSession {
                 return this.setMediaTransferActive(true, videoActive);
             }
 
-            return this.peerconnection.setSenderVideoConstraint(maxFrameHeight);
-        }
-
-        return Promise.resolve();
-    }
+            const promise = maxFrameHeight
+                ? this.peerconnection.setSenderVideoConstraints(maxFrameHeight)
+                : this.peerconnection.configureSenderVideoEncodings();
 
-    /**
-     * Sets the degradation preference on the video sender. This setting determines if
-     * resolution or framerate will be preferred when bandwidth or cpu is constrained.
-     * @returns {Promise<void>} promise that will be resolved when the operation is
-     * successful and rejected otherwise.
-     */
-    setSenderVideoDegradationPreference() {
-        if (this._assertNotEnded()) {
-            return this.peerconnection.setSenderVideoDegradationPreference();
+            return promise;
         }
 
         return Promise.resolve();
@@ -2110,14 +2086,11 @@ export default class JingleSessionPC extends JingleSession {
                     }
 
                     return promise.then(() => {
-                        if (newTrack && newTrack.isVideoTrack()) {
+                        if (newTrack?.isVideoTrack()) {
                             logger.debug(`${this} replaceTrack worker: configuring video stream`);
 
-                            // FIXME set all sender parameters in one go?
-                            // Set the degradation preference on the new video sender.
-                            return this.peerconnection.setSenderVideoDegradationPreference()
-                                .then(() => this.peerconnection.setSenderVideoConstraint())
-                                .then(() => this.peerconnection.setMaxBitRate());
+                            // Configure the video encodings after the track is replaced.
+                            return this.peerconnection.configureSenderVideoEncodings();
                         }
                     });
                 })
@@ -2262,12 +2235,10 @@ export default class JingleSessionPC extends JingleSession {
         return this._addRemoveTrackAsMuteUnmute(
             false /* add as unmute */, track)
             .then(() => {
-                // Apply the video constraints, max bitrates and degradation preference on
-                // the video sender if needed.
-                if (track.isVideoTrack() && browser.doesVideoMuteByStreamRemove()) {
-                    return this.setSenderMaxBitrates()
-                        .then(() => this.setSenderVideoDegradationPreference())
-                        .then(() => this.setSenderVideoConstraint());
+                // Configure the video encodings after the track is unmuted. If the user joins the call muted and
+                // unmutes it the first time, all the parameters need to be configured.
+                if (track.isVideoTrack()) {
+                    return this.peerconnection.configureSenderVideoEncodings();
                 }
             });
     }