feat: Use the new bridge signaling format.

Translate the 'LastNChangedEvent', 'SelectedEndpointsChangedEvent' and 'ReceiverVideoConstraint' messages into the new 'ReceiverVideoConstraints' message that invokes the new bandwidth allocation algorithm in the bridge that is described here - https://github.com/jitsi/jitsi-videobridge/blob/master/doc/allocation.md. useNewBandwidthAllocationStrategy=true in config.js will invoke the translation in the client.

modules/RTC/BridgeChannel.js

@@ -234,6 +234,19 @@ export default class BridgeChannel {
         });
     }
 
+    /**
+     * Sends a 'ReceiverVideoConstraints' message via the bridge channel.
+     *
+     * @param {ReceiverVideoConstraints} constraints video constraints.
+     */
+    sendNewReceiverVideoConstraintsMessage(constraints) {
+        logger.log(`Sending ReceiverVideoConstraints with ${JSON.stringify(constraints)}`);
+        this._send({
+            colibriClass: 'ReceiverVideoConstraints',
+            ...constraints
+        });
+    }
+
     /**
      * Set events on the given RTCDataChannel or WebSocket instance.
      */

modules/RTC/RTC.js

@@ -257,49 +257,42 @@ export default class RTC extends Listenable {
      * @param {string} [wsUrl] WebSocket URL.
      */
     initializeBridgeChannel(peerconnection, wsUrl) {
-        this._channel = new BridgeChannel(
-            peerconnection, wsUrl, this.eventEmitter);
+        this._channel = new BridgeChannel(peerconnection, wsUrl, this.eventEmitter);
 
         this._channelOpenListener = () => {
-            // When the channel becomes available, tell the bridge about
-            // video selections so that it can do adaptive simulcast,
-            // we want the notification to trigger even if userJid
-            // is undefined, or null.
-            try {
-                this._channel.sendSelectedEndpointsMessage(
-                    this._selectedEndpoints);
-
-                if (typeof this._maxFrameHeight !== 'undefined') {
-                    this._channel.sendReceiverVideoConstraintMessage(
-                        this._maxFrameHeight);
+            // When the channel becomes available, tell the bridge about video selections so that it can do adaptive
+            // simulcast, we want the notification to trigger even if userJid is undefined, or null.
+            if (this._receiverVideoConstraints) {
+                try {
+                    this._channel.sendNewReceiverVideoConstraintsMessage(this._receiverVideoConstraints);
+                } catch (error) {
+                    GlobalOnErrorHandler.callErrorHandler(error);
+                    logger.error(`Cannot send ReceiverVideoConstraints(
+                        ${JSON.stringify(this._receiverVideoConstraints)}) endpoint message`, error);
+                }
+            } else {
+                try {
+                    this._channel.sendSelectedEndpointsMessage(this._selectedEndpoints);
+                    if (typeof this._maxFrameHeight !== 'undefined') {
+                        this._channel.sendReceiverVideoConstraintMessage(this._maxFrameHeight);
+                    }
+                    if (this._lastN !== -1) {
+                        this._channel.sendSetLastNMessage(this._lastN);
+                    }
+                } catch (error) {
+                    GlobalOnErrorHandler.callErrorHandler(error);
+                    logger.error(`Cannot send selected(${this._selectedEndpoint}), lastN(${this._lastN}),`
+                        + ` frameHeight(${this._maxFrameHeight}) endpoint message`, error);
                 }
-            } catch (error) {
-                GlobalOnErrorHandler.callErrorHandler(error);
-                logger.error(
-                    `Cannot send selected(${this._selectedEndpoint})`
-                    + `frameHeight(${this._maxFrameHeight}) endpoint message`,
-                    error);
             }
 
-            this.removeListener(RTCEvents.DATA_CHANNEL_OPEN,
-                this._channelOpenListener);
+            this.removeListener(RTCEvents.DATA_CHANNEL_OPEN, this._channelOpenListener);
             this._channelOpenListener = null;
-
-            // If setLastN was invoked before the bridge channel completed
-            // opening, apply the specified value now that the channel
-            // is open. NOTE that -1 is the default value assumed by both
-            // RTC module and the JVB.
-            if (this._lastN !== -1) {
-                this._channel.sendSetLastNMessage(this._lastN);
-            }
         };
-
-        this.addListener(RTCEvents.DATA_CHANNEL_OPEN,
-            this._channelOpenListener);
+        this.addListener(RTCEvents.DATA_CHANNEL_OPEN, this._channelOpenListener);
 
         // Add Last N change listener.
-        this.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
-            this._lastNChangeListener);
+        this.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED, this._lastNChangeListener);
     }
 
     /**
@@ -358,6 +351,20 @@ export default class RTC extends Listenable {
         }
     }
 
+    /**
+     * Sets the receiver video constraints that determine how bitrate is allocated to each of the video streams
+     * requested from the bridge. The constraints are cached and sent through the bridge channel once the channel
+     * is established.
+     * @param {*} constraints
+     */
+    setNewReceiverVideoConstraints(constraints) {
+        this._receiverVideoConstraints = constraints;
+
+        if (this._channel && this._channel.isOpen()) {
+            this._channel.sendNewReceiverVideoConstraintsMessage(constraints);
+        }
+    }
+
     /**
      * Sets the maximum video size the local participant should receive from
      * remote participants. Will cache the value and send it through the channel

modules/qualitycontrol/ReceiveVideoController.js

@@ -1,6 +1,140 @@
+import { getLogger } from 'jitsi-meet-logger';
 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 
+const logger = getLogger(__filename);
+const MAX_HEIGHT_ONSTAGE = 2160;
+const MAX_HEIGHT_THUMBNAIL = 180;
+const LASTN_UNLIMITED = -1;
+
+/**
+ * This class translates the legacy signaling format between the client and the bridge (that affects bandwidth
+ * allocation) to the new format described here https://github.com/jitsi/jitsi-videobridge/blob/master/doc/allocation.md
+ */
+export class ReceiverVideoConstraints {
+    /**
+     * Creates a new instance.
+     */
+    constructor() {
+        // Default constraints used for endpoints that are not explicitly included in constraints.
+        // These constraints are used for endpoints that are thumbnails in the stage view.
+        this._defaultConstraints = { 'maxHeight': MAX_HEIGHT_THUMBNAIL };
+
+        // The number of videos requested from the bridge.
+        this._lastN = LASTN_UNLIMITED;
+
+        // The number representing the maximum video height the local client should receive from the bridge.
+        this._maxFrameHeight = MAX_HEIGHT_ONSTAGE;
+
+        // The endpoint IDs of the participants that are currently selected.
+        this._selectedEndpoints = [];
+
+        this._receiverVideoConstraints = {
+            constraints: {},
+            defaultConstraints: this.defaultConstraints,
+            lastN: this._lastN,
+            onStageEndpoints: [],
+            selectedEndpoints: this._selectedEndpoints
+        };
+    }
+
+    /**
+     * Returns the receiver video constraints that need to be sent on the bridge channel.
+     */
+    get constraints() {
+        this._receiverVideoConstraints.lastN = this._lastN;
+
+        if (!this._selectedEndpoints.length) {
+            return this._receiverVideoConstraints;
+        }
+
+        // The client is assumed to be in TileView if it has selected more than one endpoint, otherwise it is
+        // assumed to be in StageView.
+        this._receiverVideoConstraints.constraints = {};
+        if (this._selectedEndpoints.length > 1) {
+            /**
+             * Tile view.
+             * Only the default constraints are specified here along with lastN (if it is set).
+             * {
+             *  'colibriClass': 'ReceiverVideoConstraints',
+             *  'defaultConstraints': { 'maxHeight': 360 }
+             * }
+             */
+            this._receiverVideoConstraints.defaultConstraints = { 'maxHeight': this._maxFrameHeight };
+            this._receiverVideoConstraints.onStageEndpoints = [];
+            this._receiverVideoConstraints.selectedEndpoints = [];
+        } else {
+            /**
+             * Stage view.
+             * The participant on stage is specified in onStageEndpoints and a higher maxHeight is specified
+             * for that endpoint while a default maxHeight of 180 is applied to all the other endpoints.
+             * {
+             *  'colibriClass': 'ReceiverVideoConstraints',
+             *  'onStageEndpoints': ['A'],
+             *  'defaultConstraints': { 'maxHeight':  180 },
+             *  'constraints': {
+             *      'A': { 'maxHeight': 720 }
+             *   }
+             * }
+             */
+            this._receiverVideoConstraints.constraints[this._selectedEndpoints[0]] = {
+                'maxHeight': this._maxFrameHeight
+            };
+            this._receiverVideoConstraints.defaultConstraints = this._defaultConstraints;
+            this._receiverVideoConstraints.onStageEndpoints = this._selectedEndpoints;
+            this._receiverVideoConstraints.selectedEndpoints = [];
+        }
+
+        return this._receiverVideoConstraints;
+    }
+
+    /**
+     * Updates the lastN field of the ReceiverVideoConstraints sent to the bridge.
+     *
+     * @param {number} value
+     * @returns {boolean} Returns true if the the value has been updated, false otherwise.
+     */
+    updateLastN(value) {
+        const changed = this._lastN !== value;
+
+        if (changed) {
+            this._lastN = value;
+            logger.debug(`Updating ReceiverVideoConstraints lastN(${value})`);
+        }
+
+        return changed;
+    }
+
+    /**
+     * Updates the resolution (height requested) in the contraints field of the ReceiverVideoConstraints
+     * sent to the bridge.
+     *
+     * @param {number} maxFrameHeight
+     * @requires {boolean} Returns true if the the value has been updated, false otherwise.
+     */
+    updateReceiveResolution(maxFrameHeight) {
+        const changed = this._maxFrameHeight !== maxFrameHeight;
+
+        if (changed) {
+            this._maxFrameHeight = maxFrameHeight;
+            logger.debug(`Updating receive maxFrameHeight: ${maxFrameHeight}`);
+        }
+
+        return changed;
+    }
+
+    /**
+     * Updates the list of selected endpoints.
+     *
+     * @param {Array<string>} ids
+     * @returns {void}
+     */
+    updateSelectedEndpoints(ids) {
+        logger.debug(`Updating selected endpoints: ${JSON.stringify(ids)}`);
+        this._selectedEndpoints = ids;
+    }
+}
+
 /**
  * This class manages the receive video contraints for a given {@link JitsiConference}. These constraints are
  * determined by the application based on how the remote video streams need to be displayed. This class is responsible
@@ -18,11 +152,16 @@ export class ReceiveVideoController {
         this._conference = conference;
         this._rtc = rtc;
 
+        // Translate the legacy bridge channel signaling format to the new format.
+        this._receiverVideoConstraints = conference.options?.config?.useNewBandwidthAllocationStrategy
+            ? new ReceiverVideoConstraints()
+            : undefined;
+
         // The number of videos requested from the bridge, -1 represents unlimited or all available videos.
-        this._lastN = -1;
+        this._lastN = LASTN_UNLIMITED;
 
         // The number representing the maximum video height the local client should receive from the bridge.
-        this._maxFrameHeight = 2160;
+        this._maxFrameHeight = MAX_HEIGHT_ONSTAGE;
 
         // The endpoint IDs of the participants that are currently selected.
         this._selectedEndpoints = [];
@@ -53,6 +192,16 @@ export class ReceiveVideoController {
      */
     selectEndpoints(ids) {
         this._selectedEndpoints = ids;
+
+        if (this._receiverVideoConstraints) {
+            const remoteEndpointIds = ids.filter(id => id !== this._conference.myUserId());
+
+            // Filter out the local endpointId from the list of selected endpoints.
+            remoteEndpointIds.length && this._receiverVideoConstraints.updateSelectedEndpoints(remoteEndpointIds);
+            this._rtc.setNewReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
+
+            return;
+        }
         this._rtc.selectEndpoints(ids);
     }
 
@@ -66,6 +215,15 @@ export class ReceiveVideoController {
     setLastN(value) {
         if (this._lastN !== value) {
             this._lastN = value;
+
+            if (this._receiverVideoConstraints) {
+                const lastNUpdated = this._receiverVideoConstraints.updateLastN(value);
+
+                // Send out the message on the bridge channel if lastN was updated.
+                lastNUpdated && this._rtc.setNewReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
+
+                return;
+            }
             this._rtc.setLastN(value);
         }
     }
@@ -80,7 +238,14 @@ export class ReceiveVideoController {
         this._maxFrameHeight = maxFrameHeight;
 
         for (const session of this._conference._getMediaSessions()) {
-            maxFrameHeight && session.setReceiverVideoConstraint(maxFrameHeight);
+            if (session.isP2P || !this._receiverVideoConstraints) {
+                maxFrameHeight && session.setReceiverVideoConstraint(maxFrameHeight);
+            } else {
+                const resolutionUpdated = this._receiverVideoConstraints.updateReceiveResolution(maxFrameHeight);
+
+                resolutionUpdated
+                    && this._rtc.setNewReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
+            }
         }
     }
 }