ref: Calculate the local video stream height constraints based on the current state

modules/RTC/TPCUtils.js

 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import * as MediaType from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
-import * as VideoType from '../../service/RTC/VideoType';
 import browser from '../browser';
 
 const logger = getLogger(__filename);
      * 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 when
-     * simulcast is enabled.
+     * @param videoBitrates - the bitrates to be configured on the video senders for
+     * different resolutions both in unicast and simulcast mode.
      */
     constructor(peerconnection, videoBitrates) {
         this.pc = peerconnection;
         this.videoBitrates = videoBitrates;
 
         /**
-         * The simulcast encodings that will be configured on the RTCRtpSender
-         * for the video tracks in the unified plan mode.
+         * The startup configuration for the stream encodings that are applicable to
+         * the video stream when a new sender is created on the peerconnection. The initial
+         * config takes into account the differences in browser's simulcast implementation.
+         *
+         * Encoding parameters:
+         * active - determine the on/off state of a particular encoding.
+         * maxBitrate - max. bitrate value to be applied to that particular encoding
+         *  based on the encoding's resolution and config.js videoQuality settings if applicable.
+         * rid - Rtp Stream ID that is configured for a particular simulcast stream.
+         * scaleResolutionDownBy - the factor by which the encoding is scaled down from the
+         *  original resolution of the captured video.
          */
-        this.simulcastEncodings = [
+        this.localStreamEncodingsConfig = [
             {
                 active: true,
                 maxBitrate: browser.isFirefox() ? this.videoBitrates.high : this.videoBitrates.low,
                 scaleResolutionDownBy: browser.isFirefox() ? 4.0 : 1.0
             }
         ];
-
-        /**
-         * Resolution height constraints for the simulcast encodings that
-         * are configured for the video tracks.
-         */
-        this.simulcastStreamConstraints = [];
     }
 
     /**
     }
 
     /**
-     * Obtains stream encodings that need to be configured on the given track.
+     * Obtains stream encodings that need to be configured on the given track based
+     * on the track media type and the simulcast setting.
      * @param {JitsiLocalTrack} localTrack
      */
     _getStreamEncodings(localTrack) {
         if (this.pc.isSimulcastOn() && localTrack.isVideoTrack()) {
-            return this.simulcastEncodings;
+            return this.localStreamEncodingsConfig;
         }
 
-        return [ { active: true } ];
+        return localTrack.isVideoTrack()
+            ? [ {
+                active: true,
+                maxBitrate: this.videoBitrates.high
+            } ]
+            : [ { active: true } ];
     }
 
     /**
         });
     }
 
-    /**
-     * Constructs resolution height constraints for the simulcast encodings that are
-     * created for a given local video track.
-     * @param {MediaStreamTrack} track - the local video track.
-     * @returns {void}
-     */
-    setSimulcastStreamConstraints(track) {
-        if (browser.isReactNative()) {
-            return;
-        }
-
-        const height = track.getSettings().height;
-
-        for (const encoding in this.simulcastEncodings) {
-            if (this.simulcastEncodings.hasOwnProperty(encoding)) {
-                this.simulcastStreamConstraints.push({
-                    height: height / this.simulcastEncodings[encoding].scaleResolutionDownBy,
-                    rid: this.simulcastEncodings[encoding].rid
-                });
-            }
-        }
-    }
-
     /**
     * Adds {@link JitsiLocalTrack} to the WebRTC peerconnection for the first time.
     * @param {JitsiLocalTrack} track - track to be added to the peerconnection.
             // unused "recv-only" transceiver.
             this.pc.peerconnection.addTrack(track);
         }
-
-        // Construct the stream constraints for the newly added track.
-        if (localTrack.isVideoTrack() && localTrack.videoType === VideoType.CAMERA) {
-            this.setSimulcastStreamConstraints(localTrack.getTrack());
-        }
     }
 
     /**
                 return this.setEncodings(localTrack).then(() => {
                     this.pc.localTracks.set(localTrack.rtcId, localTrack);
                     transceiver.direction = 'sendrecv';
-
-                    // Construct the stream constraints for the newly added track.
-                    if (localTrack.isVideoTrack() && localTrack.videoType === VideoType.CAMERA) {
-                        this.setSimulcastStreamConstraints(localTrack.getTrack());
-                    }
                 });
             }
 
             });
     }
 
+    /**
+     * 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.
+     */
+    getLocalStreamHeightConstraints(localTrack) {
+        // React-native hasn't implemented MediaStreamTrack getSettings yet.
+        if (browser.isReactNative()) {
+            return null;
+        }
+
+        const localVideoHeightConstraints = [];
+        const height = localTrack.getSettings().height;
+
+        for (const encoding of this.localStreamEncodingsConfig) {
+            localVideoHeightConstraints.push(height / encoding.scaleResolutionDownBy);
+        }
+
+        return localVideoHeightConstraints;
+    }
+
     /**
      * Removes the track from the RTCRtpSender as part of the mute operation.
      * @param {JitsiLocalTrack} localTrack - track to be removed.

modules/RTC/TraceablePeerConnection.js

 
     let promiseChain = Promise.resolve();
 
-    if (browser.usesUnifiedPlan() && !browser.usesSdpMungingForSimulcast()) {
+    // On Firefox, the encodings have to be configured on the sender only after the transceiver is created.
+    if (browser.isFirefox()) {
         promiseChain = this.tpcUtils.setEncodings(track);
     }
 
-    // Construct the stream constraints for the newly added track.
-    if (track.isVideoTrack() && track.videoType === VideoType.CAMERA) {
-        this.tpcUtils.setSimulcastStreamConstraints(track.getTrack());
-    }
-
     return promiseChain;
 };
 
                     && videoType === VideoType.DESKTOP
                     && this.options.capScreenshareBitrate
                     ? presenterEnabled ? this.videoBitrates.high : DESKSTOP_SHARE_RATE
-                    : this.tpcUtils.simulcastEncodings[encoding].maxBitrate;
+                    : this.tpcUtils.localStreamEncodingsConfig[encoding].maxBitrate;
 
                 logger.info(`${this} Setting a max bitrate of ${bitrate} bps on layer `
-                    + `${this.tpcUtils.simulcastEncodings[encoding].rid}`);
+                    + `${this.tpcUtils.localStreamEncodingsConfig[encoding].rid}`);
                 parameters.encodings[encoding].maxBitrate = bitrate;
             }
         }
             const scaleFactor = this.senderVideoMaxHeight
                 ? Math.floor(localVideoTrack.resolution / this.senderVideoMaxHeight)
                 : 1;
-            const encoding = this.tpcUtils.simulcastEncodings
+            const encoding = this.tpcUtils.localStreamEncodingsConfig
                 .find(layer => layer.scaleResolutionDownBy === scaleFactor);
 
             if (encoding) {
     if (this.isSimulcastOn()) {
         // Determine the encodings that need to stay enabled based on the
         // new frameHeight provided.
-        const encodingsEnabledState = this.tpcUtils.simulcastStreamConstraints
-            .map(constraint => constraint.height <= newHeight);
+        const encodingsEnabledState
+            = this.tpcUtils.getLocalStreamHeightConstraints(localVideoTrack.track)
+                .map(height => height <= newHeight);
 
         for (const encoding in parameters.encodings) {
             if (parameters.encodings.hasOwnProperty(encoding)) {
         localVideoTrack.maxEnabledResolution = newHeight;
         this.eventEmitter.emit(RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED, localVideoTrack);
 
-        // Max bitrate needs to be reconfigured on the p2p connection if needed when the send resolution changes.
-        if (this.isP2P) {
+        // 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();
         }
     });