ref: Handles video constraints from the bridge. (#1227)

modules/RTC/BridgeChannel.js

      * @param {RTCPeerConnection} [peerconnection] WebRTC peer connection
      * instance.
      * @param {string} [wsUrl] WebSocket URL.
-     * @param {EventEmitter} eventEmitter EventEmitter instance.
+     * @param {EventEmitter} emitter the EventEmitter instance to use for event emission.
+     * @param {function} senderVideoConstraintsChanged callback to call when the sender video constraints change.
      */
-    constructor(peerconnection, wsUrl, emitter) {
+    constructor(peerconnection, wsUrl, emitter, senderVideoConstraintsChanged) {
         if (!peerconnection && !wsUrl) {
             throw new TypeError(
                 'At least peerconnection or wsUrl must be given');
         // Indicates whether the connection was closed from the client or not.
         this._closedFromClient = false;
 
+        this._senderVideoConstraintsChanged = senderVideoConstraintsChanged;
+
         // If a RTCPeerConnection is given, listen for new RTCDataChannel
         // event.
         if (peerconnection) {
 
                 break;
             }
-            case 'SelectedUpdateEvent': {
-                const isSelected = obj.isSelected;
+            case 'SenderVideoConstraints': {
+                const videoConstraints = obj.videoConstraints;
 
-                logger.info(`SelectedUpdateEvent isSelected? ${isSelected}`);
-                emitter.emit(RTCEvents.IS_SELECTED_CHANGED, isSelected);
+                if (videoConstraints) {
+                    logger.info(`SenderVideoConstraints: ${JSON.stringify(videoConstraints)}`);
+                    this._senderVideoConstraintsChanged(videoConstraints);
+                }
                 break;
             }
             default: {

modules/RTC/RTC.js

          */
         this._lastNEndpoints = null;
 
+        /*
+         * Holds the sender video constraints signaled from the bridge.
+         */
+        this._senderVideoConstraints = {};
+
         /**
          * The number representing the maximum video height the local client
          * should receive from the bridge.
      */
     initializeBridgeChannel(peerconnection, wsUrl) {
         this._channel = new BridgeChannel(
-            peerconnection, wsUrl, this.eventEmitter);
+            peerconnection, wsUrl, this.eventEmitter, this._senderVideoConstraintsChanged.bind(this));
 
         this._channelOpenListener = () => {
             // Mark that channel as opened.
         this._updateAudioOutputForAudioTracks(RTCUtils.getAudioOutputDevice());
     }
 
+    /**
+     * Notifies this instance that the sender video constraints signaled from the bridge have changed.
+     *
+     * @param {Object} senderVideoConstraints the sender video constraints from the bridge.
+     * @private
+     */
+    _senderVideoConstraintsChanged(senderVideoConstraints) {
+        this._senderVideoConstraints = senderVideoConstraints;
+        this.eventEmitter.emit(RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED);
+    }
+
     /**
      * Receives events when Last N had changed.
      * @param {array} lastNEndpoints The new Last N endpoints.
         return this._lastN;
     }
 
+    /**
+     * @return {Object} The sender video constraints signaled from the brridge.
+     */
+    getSenderVideoConstraints() {
+        return this._senderVideoConstraints;
+    }
+
     /**
      * Get local video track.
      * @returns {JitsiLocalTrack|undefined}

modules/RTC/TraceablePeerConnection.js

  *      disabled by removing it from the SDP.
  * @param {boolean} options.preferH264 if set to 'true' H264 will be preferred
  * over other video codecs.
- * @param {boolean} options.enableLayerSuspension if set to 'true', we will
- * cap the video send bitrate when we are told we have not been selected by
- * any endpoints (and therefore the non-thumbnail streams are not in use).
  * @param {boolean} options.startSilent If set to 'true' no audio will be sent or received.
  *
  * FIXME: initially the purpose of TraceablePeerConnection was to be able to
     return ssrcInfo;
 };
 
-const handleLayerSuspension = function(peerConnection, isSelected) {
-    if (!peerConnection.getSenders) {
-        logger.debug('Browser doesn\'t support RTPSender');
-
-        return;
-    }
-
-    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) {
-    if (this.options.enableLayerSuspension) {
-        logger.debug('Layer suspension enabled,'
-            + `currently selected? ${isSelected}`);
-        handleLayerSuspension(this.peerconnection, isSelected);
-    }
-};
-
 /**
  * Creates a text representation of this <tt>TraceablePeerConnection</tt>
  * instance.

modules/xmpp/JingleSessionPC.js

                 XmppConnection.Events.CONN_STATUS_CHANGED,
                 this.onXmppStatusChanged.bind(this))
         );
+
+        this._removeSenderVideoConstraintsChangeListener = undefined;
     }
 
     /* eslint-enable max-params */
                 = options.disableSimulcast
                     || (options.preferH264 && !options.disableH264);
             pcOptions.preferH264 = options.preferH264;
-            pcOptions.enableLayerSuspension = options.enableLayerSuspension;
 
             // disable simulcast for screenshare and set the max bitrate to
             // 500Kbps if the testing flag is present in config.js.
 
         if (!this.isP2P && options.enableLayerSuspension) {
             // If this is the bridge session, we'll listen for
-            // IS_SELECTED_CHANGED events and notify the peer connection
-            this.rtc.addListener(RTCEvents.IS_SELECTED_CHANGED,
-                isSelected => {
-                    this.peerconnection.setIsSelected(isSelected);
-                    logger.info('Doing local O/A due to '
-                        + 'IS_SELECTED_CHANGED event');
-                    this.modificationQueue.push(finishedCallback => {
-                        this._renegotiate()
-                            .then(finishedCallback)
-                            .catch(finishedCallback);
-                    });
-                }
-            );
+            // SENDER_VIDEO_CONSTRAINTS_CHANGED events and notify the peer connection
+            this._removeSenderVideoConstraintsChangeListener = this.rtc.addListener(
+                RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED, () => {
+                    this.eventEmitter.emit(
+                        MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED, this);
+                });
         }
     }
 
      * @returns {Number|undefined}
      */
     getRemoteRecvMaxFrameHeight() {
-        return this.isP2P
-            ? this.remoteRecvMaxFrameHeight
-            : undefined; // FIXME George: put a getter for the JVB's preference here
+        if (this.isP2P) {
+            return this.remoteRecvMaxFrameHeight;
+        }
+
+        return this.options.enableLayerSuspension ? this.rtc.getSenderVideoConstraints().idealHeight : undefined;
     }
 
     /**
         this._xmppListeners.forEach(removeListener => removeListener());
         this._xmppListeners = [];
 
+        if (this._removeSenderVideoConstraintsChangeListener) {
+            this._removeSenderVideoConstraintsChangeListener();
+        }
+
         this.close();
     }
 
             logger.info(`${this} received remote max frame height: ${newMaxFrameHeight}`);
             this.remoteRecvMaxFrameHeight = newMaxFrameHeight;
             this.eventEmitter.emit(
-                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
-                this,
-                newMaxFrameHeight);
+                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED, this);
         }
 
         if (newVideoSenders === null) {

modules/xmpp/JingleSessionPC.spec.js

         });
         it('fires an event when remote peer sends content-modify', () => {
             let remoteRecvMaxFrameHeight;
-            const remoteVideoConstraintsListener = (session, maxFrameHeight) => {
-                remoteRecvMaxFrameHeight = maxFrameHeight;
+            const remoteVideoConstraintsListener = session => {
+                remoteRecvMaxFrameHeight = session.getRemoteRecvMaxFrameHeight();
             };
 
             jingleSession.addListener(

service/RTC/RTCEvents.js

      */
     GRANTED_PERMISSIONS: 'rtc.granted_permissions',
 
-    IS_SELECTED_CHANGED: 'rtc.is_selected_change',
+    SENDER_VIDEO_CONSTRAINTS_CHANGED: 'rtc.sender_video_constraints_changed',
 
     /**
      * Event emitted when {@link RTC.setLastN} method is called to update with