ref(TPC): Add extra checks before updating RTCRtpEncodingParameters.

Check if all the relevant fields are correctly configured instead of checking for just the encode resolution on the local video sender.

modules/RTC/TPCUtils.js

         });
     }
 
-    /**
-     * Returns the max resolution that the client is configured to encode for a given local video track. The actual
-     * send resolution might be downscaled based on cpu and bandwidth constraints.
-     *
-     * @param {JitsiLocalTrack} localVideoTrack - The local video track.
-     * @param {CodecMimeType} codec - The codec currently in use.
-     * @returns {number|null} The max encoded resolution for the given video track.
-     */
-    getConfiguredEncodeResolution(localVideoTrack, codec) {
-        const height = localVideoTrack.getCaptureResolution();
-        const videoSender = this.pc.findSenderForTrack(localVideoTrack.getTrack());
-        let maxHeight = 0;
-
-        if (!videoSender) {
-            return null;
-        }
-        const parameters = videoSender.getParameters();
-
-        if (!parameters?.encodings?.length) {
-            return null;
-        }
-
-        // SVC mode for VP9 and AV1 codecs.
-        if (this._isRunningInFullSvcMode(codec)) {
-            const activeEncoding = parameters.encodings[0];
-
-            if (activeEncoding.active) {
-                return height / activeEncoding.scaleResolutionDownBy;
-            }
-
-            return null;
-        }
-
-        const hasIncorrectConfig = this.pc._capScreenshareBitrate
-            ? parameters.encodings.every(encoding => encoding.active)
-            : parameters.encodings.some(encoding => !encoding.active);
-
-        // Check if every encoding is active for screenshare track when low fps screenshare is configured or some
-        // of the encodings are disabled when high fps screenshare is configured. In both these cases, the track
-        // encodings need to be reconfigured. This is needed when p2p->jvb switch happens and new sender constraints
-        // are not received by the client.
-        if (localVideoTrack.getVideoType() === VideoType.DESKTOP && hasIncorrectConfig) {
-            return null;
-        }
-
-        for (const encoding in parameters.encodings) {
-            if (parameters.encodings[encoding].active) {
-                const encodingConfig = this._getVideoStreamEncodings(localVideoTrack, codec);
-                const scaleResolutionDownBy
-                    = this.pc.isSpatialScalabilityOn()
-                        ? encodingConfig[encoding].scaleResolutionDownBy
-                        : parameters.encodings[encoding].scaleResolutionDownBy;
-
-                maxHeight = Math.max(maxHeight, height / scaleResolutionDownBy);
-            }
-        }
-
-        return maxHeight;
-    }
-
     /**
      * Takes in a *unified plan* offer and inserts the appropriate parameters for adding simulcast receive support.
      * @param {Object} desc - A session description object

modules/RTC/TraceablePeerConnection.js

         return Promise.resolve();
     }
 
-    const configuredResolution = this.tpcUtils.getConfiguredEncodeResolution(
-        localVideoTrack,
-        this.getConfiguredVideoCodec());
-
-    // Ignore sender constraints if the client is already sending video of the requested resolution. Note that for
-    // screensharing sources, the max resolution will be the height of the window being captured irrespective of the
-    // height being requested by the peer.
-    if ((localVideoTrack.getVideoType() === VideoType.CAMERA && configuredResolution === frameHeight)
-        || (localVideoTrack.getVideoType() === VideoType.DESKTOP
-            && frameHeight > 0
-            && configuredResolution === localVideoTrack.getCaptureResolution())) {
-        return Promise.resolve();
-    }
-
-    this._senderMaxHeights.set(sourceName, frameHeight);
-
     return this._updateVideoSenderParameters(
         () => this._updateVideoSenderEncodings(frameHeight, localVideoTrack));
 };
         : DEGRADATION_PREFERENCE_CAMERA; // Prefer frame-rate for high fps share and camera.
 
     parameters.degradationPreference = preference;
-    logger.info(`${this} Setting degradation preference [preference=${preference},track=${localVideoTrack}`);
 
     // Calculate the encodings active state based on the resolution requested by the bridge.
     const codec = this.getConfiguredVideoCodec();
-    const maxBitrates = this.tpcUtils.calculateEncodingsBitrates(localVideoTrack, codec, frameHeight);
-    const encodingsActiveState = this.tpcUtils.calculateEncodingsActiveState(localVideoTrack, codec, frameHeight);
-    const scaleFactor = this.tpcUtils.calculateEncodingsScaleFactor(localVideoTrack, codec, frameHeight);
+    const bitrates = this.tpcUtils.calculateEncodingsBitrates(localVideoTrack, codec, frameHeight);
+    const activeState = this.tpcUtils.calculateEncodingsActiveState(localVideoTrack, codec, frameHeight);
+    const scaleFactors = this.tpcUtils.calculateEncodingsScaleFactor(localVideoTrack, codec, frameHeight);
     const scalabilityModes = this.tpcUtils.calculateEncodingsScalabilityMode(localVideoTrack, codec, frameHeight);
-
-    for (const encoding in parameters.encodings) {
-        if (parameters.encodings.hasOwnProperty(encoding)) {
-            parameters.encodings[encoding].active = encodingsActiveState[encoding];
+    let needsUpdate = false;
+
+    for (const idx in parameters.encodings) {
+        if (parameters.encodings.hasOwnProperty(idx)) {
+            const {
+                active = undefined,
+                maxBitrate = undefined,
+                scalabilityMode = undefined,
+                scaleResolutionDownBy = undefined
+            } = parameters.encodings[idx];
+
+            if (active !== activeState[idx]) {
+                parameters.encodings[idx].active = activeState[idx];
+                needsUpdate = true;
+            }
 
             // Firefox doesn't follow the spec and lets application specify the degradation preference on the
             // encodings.
-            browser.isFirefox() && (parameters.encodings[encoding].degradationPreference = preference);
+            browser.isFirefox() && (parameters.encodings[idx].degradationPreference = preference);
 
             // Do not configure 'scaleResolutionDownBy' and 'maxBitrate' for encoders running in legacy K-SVC mode
             // since the browser sends only the lowest resolution layer when those are configured.
                 || !this.isSpatialScalabilityOn()
                 || (browser.supportsScalabilityModeAPI()
                     && this.tpcUtils.codecSettings[codec].scalabilityModeEnabled)) {
-                parameters.encodings[encoding].scaleResolutionDownBy = scaleFactor[encoding];
-                parameters.encodings[encoding].maxBitrate = maxBitrates[encoding];
+                if (scaleResolutionDownBy !== scaleFactors[idx]) {
+                    parameters.encodings[idx].scaleResolutionDownBy = scaleFactors[idx];
+                    needsUpdate = true;
+                }
+                if (maxBitrate !== bitrates[idx]) {
+                    parameters.encodings[idx].maxBitrate = bitrates[idx];
+                    needsUpdate = true;
+                }
             }
 
             // Configure scalability mode when its supported and enabled.
             if (scalabilityModes) {
-                parameters.encodings[encoding].scalabilityMode = scalabilityModes[encoding];
+                if (scalabilityMode !== scalabilityModes[idx]) {
+                    parameters.encodings[idx].scalabilityMode = scalabilityModes[idx];
+                    needsUpdate = true;
+                }
             } else {
-                parameters.encodings[encoding].scalabilityMode = undefined;
+                parameters.encodings[idx].scalabilityMode = undefined;
             }
         }
     }
+
+    if (!needsUpdate) {
+        return Promise.resolve();
+    }
+
     logger.info(`${this} setting max height=${frameHeight},encodings=${JSON.stringify(parameters.encodings)}`);
 
     return videoSender.setParameters(parameters).then(() => {
+        this._senderMaxHeights.set(localVideoTrack.getSourceName(), frameHeight);
         localVideoTrack.maxEnabledResolution = frameHeight;
         this.eventEmitter.emit(RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED, localVideoTrack);
     });