Change layer suspension to use parameters in RTPSender (#786)

* Change layer suspension to use parameters in RTPSender

We no longer suspend unused simulcast layers via a bandwidth cap in the
SDP, instead we'll use the new parameters in RTPSender to enable and
disable streams explicitly.  The main advantage here is the RTPSender
method ramps up immediately when we re-enable the layers (as opposed to
the SDP bandwidth cap which took 30+ seconds).

* Fix linter issues

modules/RTC/BandwidthLimiter.js

@@ -1,88 +0,0 @@
-/* global __filename */
-
-import { getLogger } from 'jitsi-meet-logger';
-import transform from 'sdp-transform';
-
-const logger = getLogger(__filename);
-
-/**
- * This will save a bandwidth limit (per mline) that should be used
- * and then, when given an SDP, will enforce that limit.
- * Note that this will affect *outgoing* bandwidth usage, but the SDP
- * it must modify to implement that is the *remote* description
- */
-export default class BandwidthLimiter {
-
-    /**
-     * Create a new BandwidthLimiter
-     */
-    constructor() {
-        /**
-         * @type {Map<String, Number>}
-         * Map of mline media type to a bandwidth limit (in kbps).
-         * Any mlines present in this map will have the associated
-         * bandwidth limit (or 'null' for no limit) enforced, meaning
-         * that it will potentially overwrite a limit already set in
-         * the given sdp.  However, if an mline is NOT present in
-         * this map, any limit in the given sdp will not be touched.
-         */
-        this._bandwidthLimits = new Map();
-    }
-
-    /**
-     * Set a bandwidth limit for given mline.  If limitKbps is null,
-     * the limit will be removed
-     * @param {String} mediaType the mline media type to set the
-     * bandwidth limit on
-     * @param {Number} limitKbps the bandwidth limit, in kbps
-     */
-    setBandwidthLimit(mediaType, limitKbps) {
-        this._bandwidthLimits.set(mediaType, limitKbps);
-    }
-
-    /**
-     * Get the current bandwidth limit
-     * @param {String} mediaType the mline media type for which to get the
-     * bandwidth limit
-     * @return {Number} the bandwidth limit in kbps if it exists, undefined
-     * otherwise
-     */
-    getBandwidthLimit(mediaType) {
-        return this._bandwidthLimits.get(mediaType);
-    }
-
-    /**
-     * Enforce any configured bandwidth limits (or lack thereof) in the given
-     * sdp
-     * @param {String} sdp the session description
-     * @returns {String} a potentially modified session description
-     * with any configured bandwidth limits set
-     */
-    enforceBandwithLimit(sdp) {
-        logger.debug('Enforcing any configured bandwidth limits');
-        const desc = transform.parse(sdp);
-
-        desc.media.forEach(mLine => {
-            const limitKbps = this._bandwidthLimits.get(mLine.type);
-
-            if (typeof limitKbps !== 'undefined') {
-                if (limitKbps === null) {
-                    logger.debug(
-                        `Removing bandwidth limit for mline ${mLine.type}`);
-                    delete mLine.bandwidth;
-                } else {
-                    logger.debug(`Enforcing limit ${limitKbps}kbps`
-                        + ` for mline ${mLine.type}`);
-                    mLine.bandwidth = [
-                        {
-                            type: 'AS',
-                            limit: limitKbps
-                        }
-                    ];
-                }
-            }
-        });
-
-        return transform.write(desc);
-    }
-}

modules/RTC/TraceablePeerConnection.js

@@ -6,7 +6,6 @@ import transform from 'sdp-transform';
 import * as GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import * as MediaType from '../../service/RTC/MediaType';
-import BandwidthLimiter from './BandwidthLimiter';
 import LocalSdpMunger from './LocalSdpMunger';
 import RTC from './RTC';
 import RTCUtils from './RTCUtils';
@@ -208,8 +207,6 @@ export default function TraceablePeerConnection(
      */
     this.localSdpMunger = new LocalSdpMunger(this);
 
-    this.bandwidthLimiter = new BandwidthLimiter();
-
     /**
      * TracablePeerConnection uses RTC's eventEmitter
      * @type {EventEmitter}
@@ -217,12 +214,6 @@ export default function TraceablePeerConnection(
     this.eventEmitter = rtc.eventEmitter;
     this.rtxModifier = new RtxModifier();
 
-    /**
-     * Whether or not this endpoint has been selected
-     * by a remote participant (via the bridge)
-     */
-    this.isSelected = true;
-
     // override as desired
     this.trace = (what, info) => {
         logger.debug(what, info);
@@ -1036,20 +1027,6 @@ function extractSSRCMap(desc) {
     return ssrcMap;
 }
 
-/**
- * Get the bitrate cap we should enforce for video given whether or not
- * we are selected
- * @param {boolean} isSelected whether or not we (the local endpoint) is
- * selected by any other endpoints (meaning its HD stream is in use)
- * @return {Number} the bitrate cap in kbps, or null if there should be
- * no cap
- */
-function getSuspensionBitrateKbps(isSelected) {
-    // eslint-disable-next-line max-len
-    // https://codesearch.chromium.org/chromium/src/third_party/webrtc/media/engine/simulcast.cc?l=55&rcl=28deb90728c06a35d8847d2aeda2fc1aee105c5e
-    return isSelected ? null : 200;
-}
-
 /**
  * Takes a SessionDescription object and returns a "normalized" version.
  * Currently it only takes care of ordering the a=ssrc lines.
@@ -1859,21 +1836,6 @@ TraceablePeerConnection.prototype.setRemoteDescription = function(
         });
     }
 
-    if (this.options.enableLayerSuspension) {
-        logger.debug('Layer suspension enabled,'
-            + `currently selected? ${this.isSelected}`);
-        const bitrateCapKbps = getSuspensionBitrateKbps(this.isSelected);
-
-        this.bandwidthLimiter.setBandwidthLimit('video', bitrateCapKbps);
-        logger.debug(`Layer suspension got bitrate cap of ${bitrateCapKbps}`);
-        description.sdp
-            = this.bandwidthLimiter.enforceBandwithLimit(description.sdp);
-        this.trace(
-            'setRemoteDescription::postTransform '
-            + '(layer suspension bitrate cap)',
-            dumpSDP(description));
-    }
-
     // If the browser uses unified plan, transform to it first
     if (browser.usesUnifiedPlan()) {
         // eslint-disable-next-line no-param-reassign
@@ -2488,12 +2450,52 @@ TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function(track) {
     return ssrcInfo;
 };
 
+const handleLayerSuspension = function(peerConnection, isSelected) {
+    const videoSender = peerConnection.getSenders()
+        .find(sender => sender.track.kind === 'video');
+
+    if (!videoSender) {
+        logger.warn('handleLayerSuspension unable to find video sender');
+
+        return;
+    }
+    if (!videoSender.getParameters) {
+        logger.debug('Browser doesn\'t support RTPSender parameters');
+
+        return;
+    }
+    const parameters = videoSender.getParameters();
+
+    if (isSelected) {
+        logger.debug('Currently selected, enabling all sim layers');
+
+        // Make sure all encodings are enabled
+        parameters.encodings.forEach(e => {
+            e.active = true;
+        });
+    } else {
+        logger.debug('Not currently selected, disabling upper layers');
+
+        // Turn off the upper simulcast layers
+        [ 1, 2 ].forEach(simIndex => {
+            if (parameters.encodings[simIndex]) {
+                parameters.encodings[simIndex].active = false;
+            }
+        });
+    }
+    videoSender.setParameters(parameters);
+};
+
 /**
  * Set whether or not the endpoint is 'selected' by other endpoints, meaning
  * it appears on their main stage
  */
 TraceablePeerConnection.prototype.setIsSelected = function(isSelected) {
-    this.isSelected = isSelected;
+    if (this.options.enableLayerSuspension) {
+        logger.debug('Layer suspension enabled,'
+            + `currently selected? ${isSelected}`);
+        handleLayerSuspension(this.peerconnection, isSelected);
+    }
 };
 
 /**