fix(video-quality): Adjust encodings bitrates/scalefactor for high capture resolutions (#2436)

* fix(video-quality): Adjust encodings bitrates/scalefactor for high capture resolutions.
When the client is configured to capture camera sources at 1080p or higher, adjust the bitrates and the encodings scale factor accordingly.

* squash: Address review comments
Fix the bitrates set on the remote description and also bump up the bitrates for 1080p, 4k and screenshare.

* squash: Address some more review comments.

modules/RTC/TPCUtils.js

@@ -6,25 +6,19 @@ import CodecMimeType from '../../service/RTC/CodecMimeType';
 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import { MediaType } from '../../service/RTC/MediaType';
 import { getSourceIndexFromSourceName } from '../../service/RTC/SignalingLayer';
-import { STANDARD_CODEC_SETTINGS } from '../../service/RTC/StandardVideoSettings';
+import {
+    SIM_LAYERS,
+    STANDARD_CODEC_SETTINGS,
+    VIDEO_QUALITY_LEVELS,
+    VIDEO_QUALITY_SETTINGS
+} from '../../service/RTC/StandardVideoSettings';
 import VideoEncoderScalabilityMode from '../../service/RTC/VideoEncoderScalabilityMode';
 import { VideoType } from '../../service/RTC/VideoType';
 import browser from '../browser';
 
 const logger = getLogger(__filename);
-const DESKTOP_SHARE_RATE = 500000;
-const SIM_LAYER_1_RID = '1';
-const SIM_LAYER_2_RID = '2';
-const SIM_LAYER_3_RID = '3';
 const VIDEO_CODECS = [ CodecMimeType.AV1, CodecMimeType.H264, CodecMimeType.VP8, CodecMimeType.VP9 ];
 
-// TODO - need to revisit these settings when 4K is the captured resolution. We can change the LD scale factor to 6
-// instead of 4 so that the lowest resolution will be 360p instead of 540p.
-export const HD_SCALE_FACTOR = 1.0;
-export const LD_SCALE_FACTOR = 4.0;
-export const SD_SCALE_FACTOR = 2.0;
-export const SIM_LAYER_RIDS = [ SIM_LAYER_1_RID, SIM_LAYER_2_RID, SIM_LAYER_3_RID ];
-
 /**
  * Handles track related operations on TraceablePeerConnection when browser is
  * running in unified plan mode.
@@ -38,6 +32,9 @@ export class TPCUtils {
     constructor(peerconnection) {
         this.pc = peerconnection;
         this.codecSettings = clonedeep(STANDARD_CODEC_SETTINGS);
+        this.l0ScaleFactor = SIM_LAYERS[0].scaleFactor;
+        this.l1ScaleFactor = SIM_LAYERS[1].scaleFactor;
+        this.l2ScaleFactor = SIM_LAYERS[2].scaleFactor;
         const videoQualitySettings = this.pc.options?.videoQuality;
 
         if (videoQualitySettings) {
@@ -50,7 +47,9 @@ export class TPCUtils {
                         && videoQualitySettings.maxbitratesvideo[codec.toUpperCase()]);
 
                 if (bitrateSettings) {
-                    [ 'low', 'standard', 'high', 'ssHigh' ].forEach(value => {
+                    const settings = Object.values(VIDEO_QUALITY_SETTINGS);
+
+                    [ ...settings, 'ssHigh' ].forEach(value => {
                         if (bitrateSettings[value]) {
                             this.codecSettings[codec].maxBitratesVideo[value] = bitrateSettings[value];
                         }
@@ -88,40 +87,56 @@ export class TPCUtils {
      */
     _calculateActiveEncodingParams(localVideoTrack, codec, newHeight) {
         const codecBitrates = this.codecSettings[codec].maxBitratesVideo;
-        const height = localVideoTrack.getHeight();
-        const desktopShareBitrate = this.pc.options?.videoQuality?.desktopbitrate || DESKTOP_SHARE_RATE;
+        const trackCaptureHeight = localVideoTrack.getHeight();
+        const effectiveNewHeight = newHeight > trackCaptureHeight ? trackCaptureHeight : newHeight;
+        const desktopShareBitrate = this.pc.options?.videoQuality?.desktopbitrate || codecBitrates.ssHigh;
         const isScreenshare = localVideoTrack.getVideoType() === VideoType.DESKTOP;
         let scalabilityMode = this.codecSettings[codec].useKSVC
             ? VideoEncoderScalabilityMode.L3T3_KEY : VideoEncoderScalabilityMode.L3T3;
-        let maxBitrate = codecBitrates.high;
+        const { height, level } = VIDEO_QUALITY_LEVELS.find(lvl => lvl.height <= effectiveNewHeight);
+        let maxBitrate;
+        let scaleResolutionDownBy = this.l2ScaleFactor;
 
         if (this._isScreenshareBitrateCapped(localVideoTrack)) {
             scalabilityMode = VideoEncoderScalabilityMode.L1T3;
             maxBitrate = desktopShareBitrate;
-        } else if (localVideoTrack.getVideoType() === VideoType.DESKTOP) {
+        } else if (isScreenshare) {
             maxBitrate = codecBitrates.ssHigh;
+        } else {
+            maxBitrate = codecBitrates[level];
+            effectiveNewHeight && (scaleResolutionDownBy = trackCaptureHeight / effectiveNewHeight);
+
+            if (height !== effectiveNewHeight) {
+                logger.debug(`Quality level with height=${height} was picked when requested height=${newHeight} for`
+                    + `track with capture height=${trackCaptureHeight}`);
+            }
         }
 
         const config = {
-            active: newHeight > 0,
+            active: effectiveNewHeight > 0,
             maxBitrate,
             scalabilityMode,
-            scaleResolutionDownBy: HD_SCALE_FACTOR
+            scaleResolutionDownBy
         };
 
-        if (newHeight >= height || newHeight === 0 || isScreenshare) {
+        if (!config.active || isScreenshare) {
             return config;
         }
 
-        if (newHeight >= height / SD_SCALE_FACTOR) {
-            config.maxBitrate = codecBitrates.standard;
+        // Configure the sender to send all 3 spatial layers for resolutions 720p and higher.
+        switch (level) {
+        case VIDEO_QUALITY_SETTINGS.ULTRA:
+        case VIDEO_QUALITY_SETTINGS.FULL:
+        case VIDEO_QUALITY_SETTINGS.HIGH:
+            config.scalabilityMode = this.codecSettings[codec].useKSVC
+                ? VideoEncoderScalabilityMode.L3T3_KEY : VideoEncoderScalabilityMode.L3T3;
+            break;
+        case VIDEO_QUALITY_SETTINGS.STANDARD:
             config.scalabilityMode = this.codecSettings[codec].useKSVC
                 ? VideoEncoderScalabilityMode.L2T3_KEY : VideoEncoderScalabilityMode.L2T3;
-            config.scaleResolutionDownBy = SD_SCALE_FACTOR;
-        } else {
-            config.maxBitrate = codecBitrates.low;
+            break;
+        default:
             config.scalabilityMode = VideoEncoderScalabilityMode.L1T3;
-            config.scaleResolutionDownBy = LD_SCALE_FACTOR;
         }
 
         return config;
@@ -133,19 +148,21 @@ export class TPCUtils {
      * @param {JitsiLocalTrack} localTrack
      */
     _getStreamEncodings(localTrack) {
+        if (localTrack.isAudioTrack()) {
+            return [ { active: this.pc.audioTransferActive } ];
+        }
+
         const codec = this.pc.getConfiguredVideoCodec();
-        const encodings = this._getVideoStreamEncodings(localTrack.getVideoType(), codec);
+        const encodings = this._getVideoStreamEncodings(localTrack, codec);
 
-        if (this.pc.isSpatialScalabilityOn() && localTrack.isVideoTrack()) {
+        if (this.pc.isSpatialScalabilityOn()) {
             return encodings;
         }
 
-        return localTrack.isVideoTrack()
-            ? [ {
-                active: this.pc.videoTransferActive,
-                maxBitrate: this.codecSettings[codec].maxBitratesVideo.high
-            } ]
-            : [ { active: this.pc.audioTransferActive } ];
+        return [ {
+            active: this.pc.videoTransferActive,
+            maxBitrate: this.codecSettings[codec].maxBitratesVideo.high
+        } ];
     }
 
     /**
@@ -161,13 +178,26 @@ export class TPCUtils {
      * scaleResolutionDownBy - the factor by which the encoding is scaled down from the
      *  original resolution of the captured video.
      *
-     * @param {VideoType} videoType
+     * @param {JitsiLocalTrack} localTrack
      * @param {String} codec
      */
-    _getVideoStreamEncodings(videoType, codec) {
+    _getVideoStreamEncodings(localTrack, codec) {
+        const captureResolution = localTrack.getHeight();
         const codecBitrates = this.codecSettings[codec].maxBitratesVideo;
+        const videoType = localTrack.getVideoType();
+        const { level } = VIDEO_QUALITY_LEVELS.find(lvl => lvl.height <= captureResolution);
+        const maxBitrate = codecBitrates[level];
+
+        if (level === VIDEO_QUALITY_SETTINGS.ULTRA) {
+            this.l1ScaleFactor = 6.0; // 360p
+            this.l0ScaleFactor = 12.0; // 180p
+        } else if (level === VIDEO_QUALITY_SETTINGS.FULL) {
+            this.l1ScaleFactor = 3.0; // 360p
+            this.l0ScaleFactor = 6.0; // 180p
+        }
+
         const maxVideoBitrate = videoType === VideoType.DESKTOP
-            ? codecBitrates.ssHigh : codecBitrates.high;
+            ? codecBitrates.ssHigh : maxBitrate;
 
         // The SSRCs on older versions of Firefox are reversed in SDP, i.e., they have resolution order of 1:2:4 as
         // opposed to Chromium and other browsers. This has been reverted in Firefox 117 as part of the below commit.
@@ -181,20 +211,20 @@ export class TPCUtils {
             {
                 active: this.pc.videoTransferActive,
                 maxBitrate: reversedEncodings ? maxVideoBitrate : codecBitrates.low,
-                rid: SIM_LAYER_1_RID,
-                scaleResolutionDownBy: reversedEncodings ? HD_SCALE_FACTOR : LD_SCALE_FACTOR
+                rid: SIM_LAYERS[0].rid,
+                scaleResolutionDownBy: reversedEncodings ? this.l2ScaleFactor : this.l0ScaleFactor
             },
             {
                 active: this.pc.videoTransferActive,
                 maxBitrate: codecBitrates.standard,
-                rid: SIM_LAYER_2_RID,
-                scaleResolutionDownBy: SD_SCALE_FACTOR
+                rid: SIM_LAYERS[1].rid,
+                scaleResolutionDownBy: this.l1ScaleFactor
             },
             {
                 active: this.pc.videoTransferActive,
                 maxBitrate: reversedEncodings ? codecBitrates.low : maxVideoBitrate,
-                rid: SIM_LAYER_3_RID,
-                scaleResolutionDownBy: reversedEncodings ? LD_SCALE_FACTOR : HD_SCALE_FACTOR
+                rid: SIM_LAYERS[2].rid,
+                scaleResolutionDownBy: reversedEncodings ? this.l0ScaleFactor : this.l2ScaleFactor
             }
         ];
 
@@ -214,8 +244,8 @@ export class TPCUtils {
                 {
                     active: this.pc.videoTransferActive,
                     maxBitrate: maxVideoBitrate,
-                    rid: SIM_LAYER_1_RID,
-                    scaleResolutionDownBy: HD_SCALE_FACTOR,
+                    rid: SIM_LAYERS[0].rid,
+                    scaleResolutionDownBy: this.l2ScaleFactor,
                     scalabilityMode: this.codecSettings[codec].useKSVC
                         ? VideoEncoderScalabilityMode.L3T3_KEY : VideoEncoderScalabilityMode.L3T3
                 },
@@ -329,7 +359,7 @@ export class TPCUtils {
      */
     calculateEncodingsActiveState(localVideoTrack, codec, newHeight) {
         const height = localVideoTrack.getHeight();
-        const videoStreamEncodings = this._getVideoStreamEncodings(localVideoTrack.getVideoType(), codec);
+        const videoStreamEncodings = this._getVideoStreamEncodings(localVideoTrack, codec);
         const encodingsState = videoStreamEncodings
         .map(encoding => height / encoding.scaleResolutionDownBy)
         .map((frameHeight, idx) => {
@@ -353,11 +383,11 @@ export class TPCUtils {
                         // 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.
-                        || videoStreamEncodings[idx]?.scaleResolutionDownBy === LD_SCALE_FACTOR;
+                        || videoStreamEncodings[idx]?.scaleResolutionDownBy === this.l0ScaleFactor;
                 } else {
                     // For screenshare, keep the HD layer enabled always and the lower layers only for high fps
                     // screensharing.
-                    active = videoStreamEncodings[idx].scaleResolutionDownBy === HD_SCALE_FACTOR
+                    active = videoStreamEncodings[idx].scaleResolutionDownBy === this.l2ScaleFactor
                         || !this._isScreenshareBitrateCapped(localVideoTrack);
                 }
             }
@@ -378,8 +408,9 @@ export class TPCUtils {
      * @returns {Array<number>}
      */
     calculateEncodingsBitrates(localVideoTrack, codec, newHeight) {
-        const desktopShareBitrate = this.pc.options?.videoQuality?.desktopbitrate || DESKTOP_SHARE_RATE;
-        const encodingsBitrates = this._getVideoStreamEncodings(localVideoTrack.getVideoType(), codec)
+        const codecBitrates = this.codecSettings[codec].maxBitratesVideo;
+        const desktopShareBitrate = this.pc.options?.videoQuality?.desktopbitrate || codecBitrates.ssHigh;
+        const encodingsBitrates = this._getVideoStreamEncodings(localVideoTrack, codec)
         .map((encoding, idx) => {
             let bitrate = encoding.maxBitrate;
 
@@ -447,7 +478,7 @@ export class TPCUtils {
      */
     calculateEncodingsScaleFactor(localVideoTrack, codec, maxHeight) {
         if (this.pc.isSpatialScalabilityOn() && this.isRunningInSimulcastMode(codec)) {
-            return this._getVideoStreamEncodings(localVideoTrack.getVideoType(), codec)
+            return this._getVideoStreamEncodings(localVideoTrack, codec)
                 .map(encoding => encoding.scaleResolutionDownBy);
         }
 
@@ -537,19 +568,18 @@ export class TPCUtils {
         const hasIncorrectConfig = this.pc._capScreenshareBitrate
             ? parameters.encodings.every(encoding => encoding.active)
             : parameters.encodings.some(encoding => !encoding.active);
-        const videoType = localVideoTrack.getVideoType();
 
         // 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 (videoType === VideoType.DESKTOP && hasIncorrectConfig) {
+        if (localVideoTrack.getVideoType() === VideoType.DESKTOP && hasIncorrectConfig) {
             return null;
         }
 
         for (const encoding in parameters.encodings) {
             if (parameters.encodings[encoding].active) {
-                const encodingConfig = this._getVideoStreamEncodings(videoType, codec);
+                const encodingConfig = this._getVideoStreamEncodings(localVideoTrack, codec);
                 const scaleResolutionDownBy
                     = this.pc.isSpatialScalabilityOn()
                         ? encodingConfig[encoding].scaleResolutionDownBy
@@ -579,15 +609,15 @@ export class TPCUtils {
         }
         const rids = [
             {
-                id: SIM_LAYER_1_RID,
+                id: SIM_LAYERS[0].rid,
                 direction: 'recv'
             },
             {
-                id: SIM_LAYER_2_RID,
+                id: SIM_LAYERS[1].rid,
                 direction: 'recv'
             },
             {
-                id: SIM_LAYER_3_RID,
+                id: SIM_LAYERS[2].rid,
                 direction: 'recv'
             }
         ];
@@ -595,9 +625,10 @@ export class TPCUtils {
         // Firefox 72 has stopped parsing the legacy rid= parameters in simulcast attributes.
         // eslint-disable-next-line max-len
         // https://www.fxsitecompat.dev/en-CA/docs/2019/pt-and-rid-in-webrtc-simulcast-attributes-are-no-longer-supported/
+        const ridLine = rids.map(val => val.id).join(';');
         const simulcastLine = browser.isFirefox() && browser.isVersionGreaterThan(71)
-            ? `recv ${SIM_LAYER_RIDS.join(';')}`
-            : `recv rid=${SIM_LAYER_RIDS.join(';')}`;
+            ? `recv ${ridLine}`
+            : `recv rid=${ridLine}`;
         const sdp = transform.parse(desc.sdp);
         const mLines = sdp.media.filter(m => m.type === MediaType.VIDEO);
         const senderMids = Array.from(this.pc._localTrackTransceiverMids.values());

modules/RTC/TraceablePeerConnection.js

@@ -8,6 +8,7 @@ import { MediaType } from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import * as SignalingEvents from '../../service/RTC/SignalingEvents';
 import { getSourceIndexFromSourceName } from '../../service/RTC/SignalingLayer';
+import { VIDEO_QUALITY_LEVELS } from '../../service/RTC/StandardVideoSettings';
 import { VideoType } from '../../service/RTC/VideoType';
 import { SS_DEFAULT_FRAME_RATE } from '../RTC/ScreenObtainer';
 import browser from '../browser';
@@ -21,7 +22,7 @@ import { SdpTransformWrap } from '../sdp/SdpTransformUtil';
 
 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import RTC from './RTC';
-import { SIM_LAYER_RIDS, TPCUtils } from './TPCUtils';
+import { TPCUtils } from './TPCUtils';
 
 // FIXME SDP tools should end up in some kind of util module
 
@@ -284,7 +285,7 @@ export default function TraceablePeerConnection(
 
     this.interop = new Interop();
 
-    this.simulcast = new SdpSimulcast({ numOfLayers: SIM_LAYER_RIDS.length });
+    this.simulcast = new SdpSimulcast();
 
     /**
      * Munges local SDP provided to the Jingle Session in order to prevent from
@@ -300,12 +301,6 @@ export default function TraceablePeerConnection(
     this.eventEmitter = rtc.eventEmitter;
     this.rtxModifier = new RtxModifier();
 
-    /**
-     * The height constraint applied on the video sender. The default value is 2160 (4K) when layer suspension is
-     * explicitly disabled.
-     */
-    this._senderVideoMaxHeight = 2160;
-
     /**
      * The height constraints to be applied on the sender per local video source (source name as the key).
      * @type {Map<string, number>}
@@ -500,21 +495,6 @@ TraceablePeerConnection.prototype.getDesiredMediaDirection = function(mediaType,
     return hasLocalSource ? MediaDirection.RECVONLY : MediaDirection.INACTIVE;
 };
 
-/**
- * Returns the MID of the m-line associated with the local desktop track (if it exists).
- *
- * @returns {Number|null}
- */
-TraceablePeerConnection.prototype._getDesktopTrackMid = function() {
-    const desktopTrack = this.getLocalVideoTracks().find(track => track.getVideoType() === VideoType.DESKTOP);
-
-    if (desktopTrack) {
-        return Number(this._localTrackTransceiverMids.get(desktopTrack.rtcId));
-    }
-
-    return null;
-};
-
 /**
  * Returns the list of RTCRtpReceivers created for the source of the given media type associated with
  * the set of remote endpoints specified.
@@ -2067,14 +2047,23 @@ TraceablePeerConnection.prototype._setMaxBitrates = function(description, isLoca
     for (const mLine of mLines) {
         const isDoingVp9KSvc = currentCodec === CodecMimeType.VP9
             && !codecScalabilityModeSettings.scalabilityModeEnabled;
+        const localTrack = this.getLocalVideoTracks()
+            .find(track => this._localTrackTransceiverMids.get(track.rtcId) === mLine.mid.toString());
+
+        if ((isDoingVp9KSvc || this.tpcUtils._isRunningInFullSvcMode(currentCodec)) && localTrack) {
+            let maxBitrate;
+
+            if (localTrack.getVideoType() === VideoType.DESKTOP) {
+                maxBitrate = codecScalabilityModeSettings.maxBitratesVideo.ssHigh;
+            } else {
+                const { level } = VIDEO_QUALITY_LEVELS.find(lvl => lvl.height <= localTrack.getHeight());
+
+                maxBitrate = codecScalabilityModeSettings.maxBitratesVideo[level];
+            }
 
-        if (isDoingVp9KSvc || this.tpcUtils._isRunningInFullSvcMode(currentCodec)) {
-            const bitrates = codecScalabilityModeSettings.maxBitratesVideo;
-            const mid = mLine.mid;
-            const isSharingScreen = mid === this._getDesktopTrackMid();
-            const limit = Math.floor((isSharingScreen ? bitrates.ssHigh : bitrates.high) / 1000);
+            const limit = Math.floor(maxBitrate / 1000);
 
-            // Use only the HD bitrate for now as there is no API available yet for configuring
+            // Use only the highest spatial layer bitrates for now as there is no API available yet for configuring
             // the bitrates on the individual SVC layers.
             mLine.bandwidth = [ {
                 type: 'AS',

modules/connectivity/ConnectionQuality.js

@@ -1,8 +1,8 @@
 import { getLogger } from '@jitsi/logger';
 
 import * as ConferenceEvents from '../../JitsiConferenceEvents';
-import CodecMimeType from '../../service/RTC/CodecMimeType';
 import * as RTCEvents from '../../service/RTC/RTCEvents';
+import { VIDEO_QUALITY_LEVELS } from '../../service/RTC/StandardVideoSettings';
 import * as ConnectionQualityEvents from '../../service/connectivity/ConnectionQualityEvents';
 
 const Resolutions = require('../../service/RTC/Resolutions');
@@ -17,33 +17,6 @@ const logger = getLogger(__filename);
  */
 const STATS_MESSAGE_TYPE = 'stats';
 
-const kSimulcastFormats = [
-    {
-        height: 1080,
-        target: 'high'
-    },
-    {
-        height: 720,
-        target: 'high'
-    },
-    {
-        height: 540,
-        target: 'standard'
-    },
-    {
-        height: 360,
-        target: 'standard'
-    },
-    {
-        height: 270,
-        target: 'low'
-    },
-    {
-        height: 180,
-        target: 'low'
-    }
-];
-
 /**
  * The maximum bitrate to use as a measurement against the participant's current
  * bitrate. This cap helps in the cases where the participant's bitrate is high
@@ -61,32 +34,32 @@ let startBitrate = 800;
  * @param simulcast {boolean} whether simulcast is enabled or not.
  * @param resolution {Resolution} the resolution.
  * @param millisSinceStart {number} the number of milliseconds since sending video started.
- * @param videoQualitySettings {Object} the bitrate and codec settings for the local video source.
+ * @param bitrates {Object} the bitrates for the local video source.
  */
-function getTarget(simulcast, resolution, millisSinceStart, videoQualitySettings) {
+function getTarget(simulcast, resolution, millisSinceStart, bitrates) {
     let target = 0;
     let height = Math.min(resolution.height, resolution.width);
 
     // Find the first format with height no bigger than ours.
-    let simulcastFormat = kSimulcastFormats.find(f => f.height <= height);
+    let qualityLevel = VIDEO_QUALITY_LEVELS.find(f => f.height <= height);
 
-    if (simulcastFormat && simulcast && videoQualitySettings.codec === CodecMimeType.VP8) {
+    if (qualityLevel && simulcast) {
         // Sum the target fields from all simulcast layers for the given
         // resolution (e.g. 720p + 360p + 180p) for VP8 simulcast.
-        for (height = simulcastFormat.height; height >= 180; height /= 2) {
+        for (height = qualityLevel.height; height >= 180; height /= 2) {
             const targetHeight = height;
 
-            simulcastFormat = kSimulcastFormats.find(f => f.height === targetHeight);
-            if (simulcastFormat) {
-                target += videoQualitySettings[simulcastFormat.target];
+            qualityLevel = VIDEO_QUALITY_LEVELS.find(f => f.height === targetHeight);
+            if (qualityLevel) {
+                target += bitrates[qualityLevel.level];
             } else {
                 break;
             }
         }
-    } else if (simulcastFormat) {
+    } else if (qualityLevel) {
         // For VP9 SVC, H.264 (simulcast automatically disabled) and p2p, target bitrate will be
         // same as that of the individual stream bitrate.
-        target = videoQualitySettings[simulcastFormat.target];
+        target = bitrates[qualityLevel.level];
     }
 
     // Allow for an additional 1 second for ramp up -- delay any initial drop
@@ -334,19 +307,17 @@ export default class ConnectionQuality {
             const activeTPC = this._conference.getActivePeerConnection();
 
             if (activeTPC) {
-                const isSimulcastOn = activeTPC.isSpatialScalabilityOn();
-                const videoQualitySettings = activeTPC.getTargetVideoBitrates();
-
-                // Add the codec info as well.
-                videoQualitySettings.codec = activeTPC.getConfiguredVideoCodec();
-
                 // Time since sending of video was enabled.
                 const millisSinceStart = window.performance.now()
                     - Math.max(this._timeVideoUnmuted, this._timeIceConnected);
                 const statsInterval = this._options.config?.pcStatsInterval ?? 10000;
 
                 // Expected sending bitrate in perfect conditions.
-                let target = getTarget(isSimulcastOn, resolution, millisSinceStart, videoQualitySettings);
+                let target = getTarget(
+                    activeTPC.doesTrueSimulcast(),
+                    resolution,
+                    millisSinceStart,
+                    activeTPC.getTargetVideoBitrates());
 
                 target = Math.min(target, MAX_TARGET_BITRATE);
 

modules/sdp/SdpSimulcast.ts

@@ -1,19 +1,14 @@
 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import { MediaType } from '../../service/RTC/MediaType';
+import { SIM_LAYERS } from '../../service/RTC/StandardVideoSettings';
 
 import * as transform from 'sdp-transform';
 
-const DEFAULT_NUM_OF_LAYERS = 3;
-
 interface Description {
     type: RTCSdpType;
     sdp: string;
 }
 
-interface Options {
-    numOfLayers?: number
-}
-
 /**
  * This class handles SDP munging for enabling simulcast for local video streams in Unified plan. A set of random SSRCs
  * are generated for the higher layer streams and they are cached for a given mid. The cached SSRCs are then reused on
@@ -22,7 +17,7 @@ interface Options {
  * to a given endpoint.
  */
 export default class SdpSimulcast {
-    private _options: Options;
+    private _numOfLayers: number;
     private _ssrcCache: Map<string, Array<number>>;
 
     /**
@@ -30,13 +25,9 @@ export default class SdpSimulcast {
      *
      * @param options
      */
-    constructor(options: Options) {
-        this._options = options;
+    constructor() {
         this._ssrcCache = new Map();
-
-        if (!this._options.numOfLayers) {
-            this._options.numOfLayers = DEFAULT_NUM_OF_LAYERS;
-        }
+        this._numOfLayers = SIM_LAYERS.length;
     }
 
     /**
@@ -120,7 +111,7 @@ export default class SdpSimulcast {
         // Generate SIM layers.
         const simSsrcs = [];
 
-        for (let i = 0; i < this._options.numOfLayers - 1; ++i) {
+        for (let i = 0; i < this._numOfLayers - 1; ++i) {
             const simSsrc = this._generateSsrc();
 
             addAssociatedAttributes(mLine, simSsrc);

service/RTC/StandardVideoSettings.ts

@@ -1,5 +1,21 @@
 import browser from '../../modules/browser';
 
+// Default simulcast encodings config.
+export const SIM_LAYERS = [
+    {
+        rid: '1',
+        scaleFactor: 4.0
+    },
+    {
+        rid: '2',
+        scaleFactor: 2.0
+    },
+    {
+        rid: '3',
+        scaleFactor: 1.0
+    }
+];
+
 /**
  * Standard scalability mode settings for different video codecs and the default bitrates.
  */
@@ -9,7 +25,10 @@ export const STANDARD_CODEC_SETTINGS = {
             low: 100000,
             standard: 300000,
             high: 1000000,
-            ssHigh: 2500000
+            fullHd: 1200000,
+            ultraHd: 2500000,
+            ssHigh: 2500000,
+            none: 0
         },
         scalabilityModeEnabled: browser.supportsScalabilityModeAPI(),
         useSimulcast: false, // defaults to SVC.
@@ -20,7 +39,10 @@ export const STANDARD_CODEC_SETTINGS = {
             low: 200000,
             standard: 500000,
             high: 1500000,
-            ssHigh: 2500000
+            fullHd: 2000000,
+            ultraHd: 4000000,
+            ssHigh: 2500000,
+            none: 0
         },
         scalabilityModeEnabled: browser.supportsScalabilityModeAPI()
     },
@@ -29,7 +51,10 @@ export const STANDARD_CODEC_SETTINGS = {
             low: 200000,
             standard: 500000,
             high: 1500000,
-            ssHigh: 2500000
+            fullHd: 2000000,
+            ultraHd: 4000000,
+            ssHigh: 2500000,
+            none: 0
         },
         scalabilityModeEnabled: false
     },
@@ -38,10 +63,88 @@ export const STANDARD_CODEC_SETTINGS = {
             low: 100000,
             standard: 300000,
             high: 1200000,
-            ssHigh: 2500000
+            fullHd: 1500000,
+            ultraHd: 3000000,
+            ssHigh: 2500000,
+            none: 0
         },
         scalabilityModeEnabled: browser.supportsScalabilityModeAPI(),
         useSimulcast: false, // defaults to SVC.
         useKSVC: true // defaults to L3T3_KEY for SVC mode.
     }
 };
+
+/**
+ * Standard video resolutions and the corresponding quality level that will be picked for the given resolution.
+ * For quality levels:
+ * 'high' and above - the encoder will be configured to encode 3 spatial layers.
+ * 'standard' - the encoder will be configured to encode 2 spatial laters.
+ * 'low' - the encoder will be configured to encode only 1 spatial layer.
+ * In all the above cases, each of the layers will again have 3 temporal layers, except for VP8 codec for which only
+ * 2 temporal layers are configured by default.
+ */
+export const VIDEO_QUALITY_LEVELS = [
+    {
+        height: 2160,
+        level: 'ultraHd'
+    },
+    {
+        height: 1080,
+        level: 'fullHd'
+    },
+    {
+        height: 720,
+        level: 'high'
+    },
+    {
+        height: 540,
+        level: 'standard'
+    },
+    {
+        height: 480,
+        level: 'standard'
+    },
+    {
+        height: 360,
+        level: 'standard'
+    },
+    {
+        height: 270,
+        level: 'low'
+    },
+    {
+        height: 180,
+        level: 'low'
+    },
+    {
+        height: 90,
+        level: 'low'
+    },
+    {
+        height: 0,
+        level: 'none'
+    }
+];
+
+/**
+ * Enumerate the supported video resolutions.
+ */
+export enum VIDEO_QUALITY_SETTINGS {
+    // 3840x2160 or 4k.
+    ULTRA = 'ultraHd',
+
+    // 1920x1080 or full High Definition.
+    FULL = 'fullHd',
+
+    // 1280x720 or High Definition.
+    HIGH = 'high',
+
+    // 640x360 or Standard Definition.
+    STANDARD = 'standard',
+
+    // 320x180 or Low Definition.
+    LOW = 'low',
+
+    // When the camera is turned off.
+    NONE = 'none'
+};

types/hand-crafted/modules/RTC/TPCUtils.d.ts

@@ -1,7 +1,4 @@
 import JitsiLocalTrack from './JitsiLocalTrack';
-import { MediaType } from '../../service/RTC/MediaType';
-
-export const SIM_LAYER_RIDS: string[];
 
 export default class TPCUtils {
   constructor(peerconnection: unknown, videoBitrates: unknown); // TODO: