fix(quality-control) Fix receiver constraints for default case.

When the application doesn't set receiver constraints, generate default constraints in the source-name mode.
Cleanup code related to the endpoint based video constraint handling for p2p connection.

modules/qualitycontrol/ReceiveVideoController.js

@@ -5,8 +5,7 @@ import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import { MediaType } from '../../service/RTC/MediaType';
 
 const logger = getLogger(__filename);
-const MAX_HEIGHT_ONSTAGE = 2160;
-const MAX_HEIGHT_THUMBNAIL = 180;
+const MAX_HEIGHT = 2160;
 const LASTN_UNLIMITED = -1;
 
 /**
@@ -16,75 +15,35 @@ const LASTN_UNLIMITED = -1;
 class ReceiverVideoConstraints {
     /**
      * Creates a new instance.
+     *
+     * @param {number} lastN - Number of videos to be requested from the bridge.
      */
-    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 };
-
+    constructor(lastN) {
         // 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;
+        this._lastN = lastN ?? LASTN_UNLIMITED;
 
-        // The endpoint IDs of the participants that are currently selected.
-        this._selectedEndpoints = [];
+        // The number representing the maximum video height the local client should receive from the bridge/peer.
+        this._maxFrameHeight = MAX_HEIGHT;
 
         this._receiverVideoConstraints = {
             constraints: {},
-            defaultConstraints: this.defaultConstraints,
-            lastN: this._lastN,
-            onStageEndpoints: [],
-            selectedEndpoints: this._selectedEndpoints
+            defaultConstraints: { 'maxHeight': this._maxFrameHeight },
+            lastN: this._lastN
         };
     }
 
     /**
-     * Returns the receiver video constraints that need to be sent on the bridge channel.
+     * Returns the receiver video constraints that need to be sent on the bridge channel or to the remote peer.
      */
     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 = [];
+        if (Object.keys(this._receiverVideoConstraints.constraints)?.length) {
+            /* eslint-disable no-unused-vars */
+            for (const [ key, value ] of Object.entries(this._receiverVideoConstraints.constraints)) {
+                value.maxHeight = this._maxFrameHeight;
+            }
         } 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 = [];
+            this._receiverVideoConstraints.defaultConstraints = { 'maxHeight': this._maxFrameHeight };
         }
 
         return this._receiverVideoConstraints;
@@ -141,17 +100,6 @@ class ReceiverVideoConstraints {
 
         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;
-    }
 }
 
 /**
@@ -170,37 +118,23 @@ export default class ReceiveVideoController {
     constructor(conference, rtc) {
         this._conference = conference;
         this._rtc = rtc;
-
         const { config } = conference.options;
 
         // The number of videos requested from the bridge, -1 represents unlimited or all available videos.
         this._lastN = config?.startLastN ?? (config?.channelLastN || LASTN_UNLIMITED);
 
         // The number representing the maximum video height the local client should receive from the bridge.
-        this._maxFrameHeight = MAX_HEIGHT_ONSTAGE;
+        this._maxFrameHeight = MAX_HEIGHT;
 
         /**
-         * The map that holds the max frame height requested for each remote source when source-name signaling is
-         * enabled.
+         * The map that holds the max frame height requested per remote source for p2p connection.
          *
          * @type Map<string, number>
          */
         this._sourceReceiverConstraints = new Map();
 
-        // Enable new receiver constraints by default unless it is explicitly disabled through config.js.
-        const useNewReceiverConstraints = config?.useNewBandwidthAllocationStrategy ?? true;
-
-        if (useNewReceiverConstraints) {
-            this._receiverVideoConstraints = new ReceiverVideoConstraints();
-            const lastNUpdated = this._receiverVideoConstraints.updateLastN(this._lastN);
-
-            lastNUpdated && this._rtc.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
-        } else {
-            this._rtc.setLastN(this._lastN);
-        }
-
-        // The endpoint IDs of the participants that are currently selected.
-        this._selectedEndpoints = [];
+        // The default receiver video constraints.
+        this._receiverVideoConstraints = new ReceiverVideoConstraints(this._lastN);
 
         this._conference.on(
             JitsiConferenceEvents._MEDIA_SESSION_STARTED,
@@ -210,15 +144,17 @@ export default class ReceiveVideoController {
     /**
      * Returns a map of all the remote source names and the corresponding max frame heights.
      *
-     * @param {number} maxFrameHeight
+     * @param {JingleSessionPC} mediaSession - the media session.
+     * @param {number} maxFrameHeight - the height to be requested for remote sources.
      * @returns
      */
     _getDefaultSourceReceiverConstraints(mediaSession, maxFrameHeight) {
+        const height = maxFrameHeight ?? MAX_HEIGHT;
         const remoteVideoTracks = mediaSession.peerconnection?.getRemoteTracks(null, MediaType.VIDEO) || [];
         const receiverConstraints = new Map();
 
         for (const track of remoteVideoTracks) {
-            receiverConstraints.set(track.getSourceName(), maxFrameHeight);
+            receiverConstraints.set(track.getSourceName(), height);
         }
 
         return receiverConstraints;
@@ -233,10 +169,9 @@ export default class ReceiveVideoController {
      * @private
      */
     _onMediaSessionStarted(mediaSession) {
-        if (mediaSession.isP2P || !this._receiverVideoConstraints) {
-            mediaSession.setReceiverVideoConstraint(this._maxFrameHeight, this._sourceReceiverConstraints);
+        if (mediaSession.isP2P) {
+            mediaSession.setReceiverVideoConstraint(this._getDefaultSourceReceiverConstraints(mediaSession));
         } else {
-            this._receiverVideoConstraints.updateReceiveResolution(this._maxFrameHeight);
             this._rtc.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
         }
     }
@@ -250,34 +185,6 @@ export default class ReceiveVideoController {
         return this._lastN;
     }
 
-    /**
-     * Elects the participants with the given ids to be the selected participants in order to always receive video
-     * for this participant (even when last n is enabled).
-     *
-     * @param {Array<string>} ids - The user ids.
-     * @returns {void}
-     */
-    selectEndpoints(ids) {
-        this._selectedEndpoints = ids;
-
-        if (this._receiverVideoConstraints) {
-            // Filter out the local endpointId from the list of selected endpoints.
-            const remoteEndpointIds = ids.filter(id => id !== this._conference.myUserId());
-            const oldConstraints = JSON.parse(JSON.stringify(this._receiverVideoConstraints.constraints));
-
-            remoteEndpointIds.length && this._receiverVideoConstraints.updateSelectedEndpoints(remoteEndpointIds);
-            const newConstraints = this._receiverVideoConstraints.constraints;
-
-            // Send bridge message only when the constraints change.
-            if (!isEqual(newConstraints, oldConstraints)) {
-                this._rtc.setReceiverVideoConstraints(newConstraints);
-            }
-
-            return;
-        }
-        this._rtc.selectEndpoints(ids);
-    }
-
     /**
      * Selects a new value for "lastN". The requested amount of videos are going to be delivered after the value is
      * in effect. Set to -1 for unlimited or all available videos.
@@ -288,16 +195,9 @@ export default 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.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
-
-                return;
+            if (this._receiverVideoConstraints.updateLastN(value)) {
+                this._rtc.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
             }
-            this._rtc.setLastN(value);
         }
     }
 
@@ -311,15 +211,10 @@ export default class ReceiveVideoController {
         this._maxFrameHeight = maxFrameHeight;
 
         for (const session of this._conference.getMediaSessions()) {
-            if (session.isP2P || !this._receiverVideoConstraints) {
-                session.setReceiverVideoConstraint(
-                    maxFrameHeight,
-                    this._getDefaultSourceReceiverConstraints(this._maxFrameHeight));
-            } else {
-                const resolutionUpdated = this._receiverVideoConstraints.updateReceiveResolution(maxFrameHeight);
-
-                resolutionUpdated
-                    && this._rtc.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
+            if (session.isP2P) {
+                session.setReceiverVideoConstraint(this._getDefaultSourceReceiverConstraints(session, maxFrameHeight));
+            } else if (this._receiverVideoConstraints.updateReceiveResolution(maxFrameHeight)) {
+                this._rtc.setReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
             }
         }
     }
@@ -344,7 +239,8 @@ export default class ReceiveVideoController {
 
         if (constraintsChanged) {
             this._lastN = constraints.lastN ?? this._lastN;
-            this._selectedEndpoints = constraints.selectedEndpoints ?? this._selectedEndpoints;
+
+            // Send the contraints on the bridge channel.
             this._rtc.setReceiverVideoConstraints(constraints);
 
             const p2pSession = this._conference.getMediaSessions().find(session => session.isP2P);
@@ -363,7 +259,7 @@ export default class ReceiveVideoController {
             this._sourceReceiverConstraints = new Map(mappedConstraints);
 
             // Send the receiver constraints to the peer through a "content-modify" message.
-            p2pSession.setReceiverVideoConstraint(null, this._sourceReceiverConstraints);
+            p2pSession.setReceiverVideoConstraint(this._sourceReceiverConstraints);
         }
     }
 }

modules/xmpp/JingleSessionPC.js

@@ -135,18 +135,6 @@ export default class JingleSessionPC extends JingleSession {
         return null;
     }
 
-    /**
-     * Parses the video max frame height value out of the 'content-modify' IQ.
-     *
-     * @param {jQuery} jingleContents - A jQuery selector pointing to the '>jingle' element.
-     * @returns {Number|null}
-     */
-    static parseMaxFrameHeight(jingleContents) {
-        const maxFrameHeightSel = jingleContents.find('>content[name="video"]>max-frame-height');
-
-        return maxFrameHeightSel.length ? Number(maxFrameHeightSel.text()) : null;
-    }
-
     /**
      * Parses the source-name and max frame height value of the 'content-modify' IQ when source-name signaling
      * is enabled.
@@ -255,15 +243,7 @@ export default class JingleSessionPC extends JingleSession {
         this._gatheringStartedTimestamp = null;
 
         /**
-         * Local preference for the receive video max frame height.
-         *
-         * @type {Number|undefined}
-         */
-        this.localRecvMaxFrameHeight = undefined;
-
-        /**
-         * Receiver constraints (max height) set by the application per remote source. Will be used for p2p connection
-         * in lieu of localRecvMaxFrameHeight when source-name signaling is enabled.
+         * Receiver constraints (max height) set by the application per remote source. Will be used for p2p connection.
          *
          * @type {Map<string, number>}
          */
@@ -1237,9 +1217,7 @@ export default class JingleSessionPC extends JingleSession {
                         // up our SDP translation chain (simulcast, video mute, RTX etc.)
                         // #2 Sends the max frame height if it was set, before the session-initiate/accept
                         if (this.isP2P
-                            && (!this._localVideoActive
-                                || this.localRecvMaxFrameHeight
-                                || this._sourceReceiverConstraints)) {
+                            && (!this._localVideoActive || this._sourceReceiverConstraints)) {
                             this.sendContentModify();
                         }
                     }
@@ -1453,10 +1431,8 @@ export default class JingleSessionPC extends JingleSession {
      * @private
      */
     sendContentModify() {
-        const maxFrameHeight = this.localRecvMaxFrameHeight;
         const senders = this._localVideoActive ? 'both' : 'none';
-
-        let sessionModify
+        const sessionModify
             = $iq({
                 to: this.remoteJid,
                 type: 'set'
@@ -1472,14 +1448,6 @@ export default class JingleSessionPC extends JingleSession {
                     senders
                 });
 
-        if (typeof maxFrameHeight !== 'undefined') {
-            sessionModify = sessionModify
-                .c('max-frame-height', { xmlns: 'http://jitsi.org/jitmeet/video' })
-                .t(maxFrameHeight);
-            logger.info(`${this} sending content-modify, video senders: ${senders},`
-                + ` max frame height: ${maxFrameHeight}`);
-        }
-
         if (typeof this._sourceReceiverConstraints !== 'undefined') {
             this._sourceReceiverConstraints.forEach((maxHeight, sourceName) => {
                 sessionModify
@@ -1505,15 +1473,12 @@ export default class JingleSessionPC extends JingleSession {
 
     /**
      * Adjust the preference for max video frame height that the local party is willing to receive. Signals
-     * the remote party.
+     * the remote p2p peer.
      *
-     * @param {Number} maxFrameHeight - the new value to set.
      * @param {Map<string, number>} sourceReceiverConstraints - The receiver constraints per source.
      */
-    setReceiverVideoConstraint(maxFrameHeight, sourceReceiverConstraints) {
-        logger.info(`${this} setReceiverVideoConstraint - max frame height: ${maxFrameHeight}`
-            + ` sourceReceiverConstraints: ${sourceReceiverConstraints}`);
-
+    setReceiverVideoConstraint(sourceReceiverConstraints) {
+        logger.info(`${this} setReceiverVideoConstraint - constraints: ${JSON.stringify(sourceReceiverConstraints)}`);
         this._sourceReceiverConstraints = sourceReceiverConstraints;
 
         if (this.isP2P) {
@@ -2735,16 +2700,8 @@ export default class JingleSessionPC extends JingleSession {
      */
     modifyContents(jingleContents) {
         const newVideoSenders = JingleSessionPC.parseVideoSenders(jingleContents);
-        const newMaxFrameHeight = JingleSessionPC.parseMaxFrameHeight(jingleContents);
         const sourceMaxFrameHeights = JingleSessionPC.parseSourceMaxFrameHeight(jingleContents);
 
-        // frame height is optional in our content-modify protocol
-        if (newMaxFrameHeight) {
-            logger.info(`${this} received remote max frame height: ${newMaxFrameHeight}`);
-            this.remoteRecvMaxFrameHeight = newMaxFrameHeight;
-            this.eventEmitter.emit(MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED, this);
-        }
-
         if (sourceMaxFrameHeights) {
             this.remoteSourceMaxFrameHeights = sourceMaxFrameHeights;
             this.eventEmitter.emit(MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED, this, sourceMaxFrameHeights);

modules/xmpp/JingleSessionPC.spec.js

@@ -75,7 +75,7 @@ describe('JingleSessionPC', () => {
             sourceConstraints.set('8d519815-v0', 180);
             sourceConstraints.set('8d519815-v1', 2160);
 
-            jingleSession.setReceiverVideoConstraint(null, sourceConstraints);
+            jingleSession.setReceiverVideoConstraint(sourceConstraints);
 
             expect(jingleSession.getState()).toBe(JingleSessionState.PENDING);
 

modules/xmpp/MediaSessionEvents.spec.ts

@@ -5,13 +5,11 @@ import { default as exported } from "./MediaSessionEvents";
 describe( "/modules/xmpp/MediaSessionEvents members", () => {
     const {
         REMOTE_SOURCE_CONSTRAINTS_CHANGED,
-        REMOTE_VIDEO_CONSTRAINTS_CHANGED,
         ...others
     } = exported;
 
     it( "known members", () => {
         expect( REMOTE_SOURCE_CONSTRAINTS_CHANGED ).toBe( 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED' );
-        expect( REMOTE_VIDEO_CONSTRAINTS_CHANGED ).toBe( 'media_session.REMOTE_VIDEO_CONSTRAINTS_CHANGED' );
     } );
 
     it( "unknown members", () => {

modules/xmpp/MediaSessionEvents.ts

@@ -2,12 +2,7 @@ enum MediaSessionEvents {
     /**
      * Event triggered when the remote party signals video max frame heights for its local sources.
      */
-    REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED',
-
-    /**
-     * Event triggered when the remote party signals it's receive video max frame height.
-     */
-    REMOTE_VIDEO_CONSTRAINTS_CHANGED = 'media_session.REMOTE_VIDEO_CONSTRAINTS_CHANGED'
+    REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED'
 };
 
 export default MediaSessionEvents;

modules/xmpp/strophe.jingle.js

@@ -232,9 +232,7 @@ export default class JingleConnectionPlugin extends ConnectionPlugin {
             break;
         }
         case 'content-modify': {
-            const height = $(iq).find('jingle>content[name="video"]>max-frame-height');
-
-            logger.debug(`Received ${action} from ${fromJid} with a max-frame-height=${height?.text()}`);
+            logger.debug(`Received ${action} from ${fromJid}`);
             sess.modifyContents($(iq).find('>jingle'));
             break;
         }

types/hand-crafted/modules/qualitycontrol/ReceiveVideoController.d.ts

@@ -6,14 +6,11 @@ export class ReceiverVideoConstraints {
   updateLastN: ( value: number ) => boolean;
   updateReceiveResolution: ( maxFrameHeight: number ) => boolean;
   updateReceiverVideoConstraints: ( videoConstraints: ReceiverVideoConstraints ) => boolean; // TODO:
-  updateSelectedEndpoints: ( ids: unknown ) => void; // TODO:
 }
 
 export class ReceiveVideoController {
   constructor( conference: JitsiConference, rtc: RTC );
   getLastN: () => number;
-  selectEndpoints: ( ids: unknown ) => unknown; // TODO:
   setLastN: ( value: number ) => void;
-  setPreferredReceiveMaxFrameHeight: ( maxFrameHeight: number ) => void;
   setReceiverConstraints: ( constraints: ReceiverVideoConstraints ) => void;
 }

types/hand-crafted/modules/xmpp/JingleSessionPC.d.ts

@@ -6,7 +6,6 @@ import JitsiRemoteTrack from '../RTC/JitsiRemoteTrack';
 
 export default class JingleSessionPC extends JingleSession {
   static parseVideoSenders: ( jingleContents: JQuery ) => string | null;
-  static parseMaxFrameHeight: ( jingleContents: JQuery ) => number | null;
   constructor( sid: string, localJid: string, remoteJid: string, connection: XmppConnection, mediaConstraints: unknown, iceConfig: unknown, isP2P: boolean, isInitiator: boolean ); // TODO:
   doInitialize: ( options: {} ) => void;
   getRemoteRecvMaxFrameHeight: () => number | undefined;

types/hand-crafted/modules/xmpp/MediaSessionEvents.d.ts

@@ -1,3 +1,3 @@
 export enum MediaSessionEvents {
-  REMOTE_VIDEO_CONSTRAINTS_CHANGED = 'media_session.REMOTE_VIDEO_CONSTRAINTS_CHANGED'
+  REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED'
 }