fix(video-quality) Update frame heights in content-modify for p2p. (#1983)

* fix(video-quality) Update frame heights in content-modify for p2p.
When the user changes the preferred video quality settings from the UI, update the frame height values in content-modify for p2p connection when source-name signaling is enabled.

* fix(multi-stream) Send presence for desktop track before signaling when it is the first track to be added to the conference.
Also do not suppress renegotiation for desktop track on p2p since the browser doesn't fire negotiation needed event.

* squash: fix build

* squash: fix linter issues

* squash: add comment.

JitsiConference.js

@@ -1123,7 +1123,15 @@ JitsiConference.prototype.addTrack = function(track) {
         return Promise.reject(new Error(`Cannot add second ${mediaType} track to the conference`));
     }
 
-    return this.replaceTrack(null, track);
+    return this.replaceTrack(null, track)
+        .then(() => {
+            // Presence needs to be sent here for desktop track since we need the presence to reach the remote peer
+            // before signaling so that a fake participant tile is created for screenshare. Otherwise, presence will
+            // only be sent after a session-accept or source-add is ack'ed.
+            if (track.getVideoType() === VideoType.DESKTOP && FeatureFlags.isMultiStreamSupportEnabled()) {
+                this._updateRoomPresence(this.getActiveMediaSession());
+            }
+        });
 };
 
 /**

modules/RTC/TraceablePeerConnection.js

@@ -1977,7 +1977,8 @@ TraceablePeerConnection.prototype.replaceTrack = function(oldTrack, newTrack) {
     // FIXME - This check needs to be removed when the client switches to the bridge based signaling for tracks.
     const isNewTrackScreenshare = !oldTrack
         && newTrack?.getVideoType() === VideoType.DESKTOP
-        && FeatureFlags.isMultiStreamSupportEnabled();
+        && FeatureFlags.isMultiStreamSupportEnabled()
+        && !this.isP2P; // negotiationneeded is not fired on p2p peerconnection
     const negotiationNeeded = !isNewTrackScreenshare && Boolean(!oldTrack || !this.localTracks.has(oldTrack?.rtcId));
 
     if (this._usesUnifiedPlan) {

modules/qualitycontrol/ReceiveVideoController.js

@@ -2,6 +2,7 @@ import { getLogger } from '@jitsi/logger';
 import isEqual from 'lodash.isequal';
 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import { MediaType } from '../../service/RTC/MediaType';
 import FeatureFlags from '../flags/FeatureFlags';
 
 const logger = getLogger(__filename);
@@ -179,6 +180,14 @@ export default class ReceiveVideoController {
         // The number representing the maximum video height the local client should receive from the bridge.
         this._maxFrameHeight = MAX_HEIGHT_ONSTAGE;
 
+        /**
+         * The map that holds the max frame height requested for each remote source when source-name signaling is
+         * enabled.
+         *
+         * @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;
 
@@ -199,6 +208,26 @@ export default class ReceiveVideoController {
             session => this._onMediaSessionStarted(session));
     }
 
+    /**
+     * Returns a map of all the remote source names and the corresponding max frame heights.
+     *
+     * @param {number} maxFrameHeight
+     * @returns
+     */
+    _getDefaultSourceReceiverConstraints(mediaSession, maxFrameHeight) {
+        if (!FeatureFlags.isSourceNameSignalingEnabled()) {
+            return null;
+        }
+        const remoteVideoTracks = mediaSession.peerconnection?.getRemoteTracks(null, MediaType.VIDEO) || [];
+        const receiverConstraints = new Map();
+
+        for (const track of remoteVideoTracks) {
+            receiverConstraints.set(track.getSourceName(), maxFrameHeight);
+        }
+
+        return receiverConstraints;
+    }
+
     /**
      * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
      * session. The preferred receive frameHeight is applied on the media session.
@@ -209,7 +238,7 @@ export default class ReceiveVideoController {
      */
     _onMediaSessionStarted(mediaSession) {
         if (mediaSession.isP2P || !this._receiverVideoConstraints) {
-            mediaSession.setReceiverVideoConstraint(this._maxFrameHeight);
+            mediaSession.setReceiverVideoConstraint(this._maxFrameHeight, this._sourceReceiverConstraints);
         } else {
             this._receiverVideoConstraints.updateReceiveResolution(this._maxFrameHeight);
             this._rtc.setNewReceiverVideoConstraints(this._receiverVideoConstraints.constraints);
@@ -287,7 +316,9 @@ export default class ReceiveVideoController {
 
         for (const session of this._conference.getMediaSessions()) {
             if (session.isP2P || !this._receiverVideoConstraints) {
-                maxFrameHeight && session.setReceiverVideoConstraint(maxFrameHeight);
+                session.setReceiverVideoConstraint(
+                    maxFrameHeight,
+                    this._getDefaultSourceReceiverConstraints(this._maxFrameHeight));
             } else {
                 const resolutionUpdated = this._receiverVideoConstraints.updateReceiveResolution(maxFrameHeight);
 
@@ -330,7 +361,23 @@ export default class ReceiveVideoController {
 
             const p2pSession = this._conference.getMediaSessions().find(session => session.isP2P);
 
-            if (p2pSession) {
+            if (!p2pSession) {
+                return;
+            }
+
+            if (FeatureFlags.isSourceNameSignalingEnabled()) {
+                const mappedConstraints = Array.from(Object.entries(constraints.constraints))
+                    .map(constraint => {
+                        constraint[1] = constraint[1].maxHeight;
+
+                        return constraint;
+                    });
+
+                this._sourceReceiverConstraints = new Map(mappedConstraints);
+
+                // Send the receiver constraints to the peer through a "content-modify" message.
+                p2pSession.setReceiverVideoConstraint(null, this._sourceReceiverConstraints);
+            } else {
                 let maxFrameHeight = Object.values(constraints.constraints)[0]?.maxHeight;
 
                 if (!maxFrameHeight) {

modules/qualitycontrol/SendVideoController.js

@@ -66,19 +66,25 @@ export default class SendVideoController {
     /**
      * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
      * session. It doesn't mean it's already active though. For example the JVB connection may be created after
-     * the conference has entered the p2p mode already.
+-    * the conference has entered the p2p mode already.
      *
      * @param {JingleSessionPC} mediaSession - the started media session.
      * @private
      */
     _onMediaSessionStarted(mediaSession) {
-        mediaSession.addListener(
-            MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
-            session => {
-                if (session === this._conference.getActiveMediaSession()) {
-                    this._configureConstraintsForLocalSources();
-                }
-            });
+        if (FeatureFlags.isSourceNameSignalingEnabled()) {
+            mediaSession.addListener(
+                MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED,
+                (session, sourceConstraints) => {
+                    session === this._conference.getActiveMediaSession()
+                        && sourceConstraints.forEach(constraint => this._onSenderConstraintsReceived(constraint));
+                });
+        } else {
+            mediaSession.addListener(
+                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
+                session => session === this._conference.getActiveMediaSession()
+                    && this._configureConstraintsForLocalSources());
+        }
     }
 
     /**
@@ -148,7 +154,9 @@ export default class SendVideoController {
         const activeMediaSession = this._conference.getActiveMediaSession();
         const remoteRecvMaxFrameHeight = activeMediaSession
             ? activeMediaSession.isP2P
-                ? activeMediaSession.getRemoteRecvMaxFrameHeight()
+                ? sourceName
+                    ? this._sourceSenderConstraints.get(sourceName)
+                    : activeMediaSession.getRemoteRecvMaxFrameHeight()
                 : sourceName ? this._sourceSenderConstraints.get(sourceName) : this._senderVideoConstraints?.idealHeight
             : undefined;
 

modules/xmpp/JingleSessionPC.js

@@ -122,6 +122,34 @@ export default class JingleSessionPC extends JingleSession {
         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.
+     *
+     * @param {jQuery} jingleContents - A jQuery selector pointing to the '>jingle' element.
+     * @returns {Object|null}
+     */
+    static parseSourceMaxFrameHeight(jingleContents) {
+        const receiverConstraints = [];
+        const sourceFrameHeightSel = jingleContents.find('>content[name="video"]>source-frame-height');
+        let maxHeight, sourceName;
+
+        if (sourceFrameHeightSel.length) {
+            sourceFrameHeightSel.each((_, source) => {
+                sourceName = source.getAttribute('sourceName');
+                maxHeight = source.getAttribute('maxHeight');
+                receiverConstraints.push({
+                    maxHeight,
+                    sourceName
+                });
+            });
+
+            return receiverConstraints;
+        }
+
+        return null;
+    }
+
     /* eslint-disable max-params */
 
     /**
@@ -208,6 +236,14 @@ export default class JingleSessionPC extends JingleSession {
          */
         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.
+         *
+         * @type {Map<string, number>}
+         */
+        this._sourceReceiverConstraints = undefined;
+
         /**
          * Indicates whether or not this session is willing to send/receive
          * video media. When set to <tt>false</tt> the underlying peer
@@ -263,6 +299,13 @@ export default class JingleSessionPC extends JingleSession {
          */
         this.remoteRecvMaxFrameHeight = undefined;
 
+        /**
+         * Remote preference for the receive video max frame heights when source-name signaling is enabled.
+         *
+         * @type {Map<string, number>|undefined}
+         */
+        this.remoteSourceMaxFrameHeights = undefined;
+
         /**
          * The queue used to serialize operations done on the peerconnection.
          *
@@ -640,6 +683,19 @@ export default class JingleSessionPC extends JingleSession {
         return undefined;
     }
 
+    /**
+     * Remote preference for receive video max frame heights when source-name signaling is enabled.
+     *
+     * @returns {Map<string, number>|undefined}
+     */
+    getRemoteSourcesRecvMaxFrameHeight() {
+        if (this.isP2P) {
+            return this.remoteSourceMaxFrameHeights;
+        }
+
+        return undefined;
+    }
+
     /**
      * Sends given candidate in Jingle 'transport-info' message.
      * @param {RTCIceCandidate} candidate the WebRTC ICE candidate instance
@@ -1168,7 +1224,9 @@ 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._localVideoActive
+                                || this.localRecvMaxFrameHeight
+                                || this._sourceReceiverConstraints)) {
                             this.sendContentModify();
                         }
                     }
@@ -1407,9 +1465,24 @@ export default class JingleSessionPC extends JingleSession {
             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
+                    .c('source-frame-height', { xmlns: 'http://jitsi.org/jitmeet/video' })
+                    .attrs({
+                        sourceName,
+                        maxHeight
+                    });
+
+                sessionModify.up();
+                logger.info(`${this} sending content-modify for source-name: ${sourceName}, maxHeight: ${maxHeight}`);
+            });
         }
 
-        logger.info(`${this} sending content-modify, video senders: ${senders}, max frame height: ${maxFrameHeight}`);
         logger.debug(sessionModify.tree());
 
         this.connection.sendIQ(
@@ -1424,11 +1497,17 @@ export default class JingleSessionPC extends JingleSession {
      * the remote party.
      *
      * @param {Number} maxFrameHeight - the new value to set.
+     * @param {Map<string, number>} sourceReceiverConstraints - The receiver constraints per source.
      */
-    setReceiverVideoConstraint(maxFrameHeight) {
-        logger.info(`${this} setReceiverVideoConstraint - max frame height: ${maxFrameHeight}`);
+    setReceiverVideoConstraint(maxFrameHeight, sourceReceiverConstraints) {
+        logger.info(`${this} setReceiverVideoConstraint - max frame height: ${maxFrameHeight}`
+            + ` sourceReceiverConstraints: ${sourceReceiverConstraints}`);
 
-        this.localRecvMaxFrameHeight = maxFrameHeight;
+        if (FeatureFlags.isSourceNameSignalingEnabled()) {
+            this._sourceReceiverConstraints = sourceReceiverConstraints;
+        } else {
+            this.localRecvMaxFrameHeight = maxFrameHeight;
+        }
 
         if (this.isP2P) {
             // Tell the remote peer about our receive constraint. If Jingle session is not yet active the state will
@@ -1436,8 +1515,6 @@ export default class JingleSessionPC extends JingleSession {
             if (this.state === JingleSessionState.ACTIVE) {
                 this.sendContentModify();
             }
-        } else {
-            this.rtc.setReceiverVideoConstraint(maxFrameHeight);
         }
     }
 
@@ -2524,32 +2601,31 @@ export default class JingleSessionPC extends JingleSession {
      * @see {@link _localVideoActive}
      */
     modifyContents(jingleContents) {
-        const newVideoSenders
-            = JingleSessionPC.parseVideoSenders(jingleContents);
-        const newMaxFrameHeight
-            = JingleSessionPC.parseMaxFrameHeight(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);
+            this.eventEmitter.emit(MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED, this);
+        }
+
+        if (sourceMaxFrameHeights) {
+            this.remoteSourceMaxFrameHeights = sourceMaxFrameHeights;
+            this.eventEmitter.emit(MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED, this, sourceMaxFrameHeights);
         }
 
         if (newVideoSenders === null) {
-            logger.error(
-                `${this} - failed to parse video "senders" attribute in`
-                    + '"content-modify" action');
+            logger.error(`${this} - failed to parse video "senders" attribute in "content-modify" action`);
 
             return;
         }
 
         const workFunction = finishedCallback => {
-            if (this._assertNotEnded('content-modify')
-                    && this._modifyRemoteVideoActive(newVideoSenders)) {
-                // Will do the sRD/sLD cycle to update SDPs and adjust
-                // the media direction
+            if (this._assertNotEnded() && this._modifyRemoteVideoActive(newVideoSenders)) {
+                // Will do the sRD/sLD cycle to update SDPs and adjust the media direction.
                 this._renegotiate()
                     .then(finishedCallback, finishedCallback /* (error) */);
             } else {
@@ -2591,8 +2667,7 @@ export default class JingleSessionPC extends JingleSession {
             this._remoteVideoActive = isRemoteVideoActive;
         }
 
-        return this.peerconnection.setVideoTransferActive(
-            this._localVideoActive && this._remoteVideoActive);
+        return this.peerconnection.setVideoTransferActive(this._localVideoActive && this._remoteVideoActive);
     }
 
     /**

modules/xmpp/JingleSessionPC.spec.js

@@ -1,5 +1,6 @@
 /* global $, jQuery */
 import { MockRTC } from '../RTC/MockClasses';
+import FeatureFlags from '../flags/FeatureFlags';
 
 import JingleSessionPC from './JingleSessionPC';
 import * as JingleSessionState from './JingleSessionState';
@@ -23,7 +24,23 @@ function createContentModify(senders = 'both', maxFrameHeight) {
     return $(modifyContentsIq).find('>jingle');
 }
 
-describe('JingleSessionPC', () => {
+/**
+ * Creates 'content-modify' Jingle IQ.
+ * @returns {jQuery}
+ */
+function createContentModifyForSourceNames() {
+    const modifyContentsIq = jQuery.parseXML(
+        '<jingle action="content-modify" initiator="peer2" sid="sid12345" xmlns="urn:xmpp:jingle:1">'
+        + '<content name="video" senders="both">'
+        + '<source-frame-height maxHeight="180" sourceName="8d519815-v0" xmlns="http://jitsi.org/jitmeet/video"/>'
+        + '<source-frame-height maxHeight="2160" sourceName="8d519815-v1" xmlns="http://jitsi.org/jitmeet/video"/>'
+        + '</content>'
+        + '</jingle>');
+
+    return $(modifyContentsIq).find('>jingle');
+}
+
+describe('JingleSessionPC w/o source-name signaling', () => {
     let jingleSession;
     let connection;
     let rtc;
@@ -62,7 +79,11 @@ describe('JingleSessionPC', () => {
         // connection.connect('jid', undefined, () => { }); */
     });
 
-    describe('send/receive video constraints', () => {
+    describe('send/receive video constraints w/o source-name', () => {
+        beforeEach(() => {
+            FeatureFlags.init({ sourceNameSignaling: false });
+        });
+
         it('sends content-modify with recv frame size', () => {
             const sendIQSpy = spyOn(connection, 'sendIQ').and.callThrough();
 
@@ -120,4 +141,72 @@ describe('JingleSessionPC', () => {
             });
         });
     });
+
+    describe('send/receive video constraints w/ source-name', () => {
+        beforeEach(() => {
+            FeatureFlags.init({ sourceNameSignaling: true });
+        });
+
+        it('sends content-modify with recv frame size', () => {
+            const sendIQSpy = spyOn(connection, 'sendIQ').and.callThrough();
+            const sourceConstraints = new Map();
+
+            sourceConstraints.set('8d519815-v0', 180);
+            sourceConstraints.set('8d519815-v1', 2160);
+
+            jingleSession.setReceiverVideoConstraint(null, sourceConstraints);
+
+            expect(jingleSession.getState()).toBe(JingleSessionState.PENDING);
+
+            return new Promise((resolve, reject) => {
+                jingleSession.acceptOffer(
+                    offerIQ,
+                    resolve,
+                    reject,
+                    /* local tracks */ []);
+            }).then(() => {
+                expect(jingleSession.getState()).toBe(JingleSessionState.ACTIVE);
+
+                // FIXME content-modify is sent before session-accept
+                expect(sendIQSpy.calls.count()).toBe(2);
+
+                expect(sendIQSpy.calls.first().args[0].toString()).toBe(
+                    '<iq to="peer2" type="set" xmlns="jabber:client">'
+                    + '<jingle action="content-modify" initiator="peer2" sid="sid12345" xmlns="urn:xmpp:jingle:1">'
+                    + '<content name="video" senders="both">'
+                    + '<source-frame-height maxHeight="180" sourceName="8d519815-v0"'
+                    + ' xmlns="http://jitsi.org/jitmeet/video"/>'
+                    + '<source-frame-height maxHeight="2160" sourceName="8d519815-v1"'
+                    + ' xmlns="http://jitsi.org/jitmeet/video"/>'
+                    + '</content>'
+                    + '</jingle>'
+                    + '</iq>');
+            });
+        });
+        it('fires an event when remote peer sends content-modify', () => {
+            let remoteSourcesRecvMaxFrameHeight;
+            const remoteVideoConstraintsListener = () => {
+                remoteSourcesRecvMaxFrameHeight = jingleSession.getRemoteSourcesRecvMaxFrameHeight();
+            };
+
+            jingleSession.addListener(
+                MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED,
+                remoteVideoConstraintsListener);
+
+            return new Promise((resolve, reject) => {
+                jingleSession.acceptOffer(
+                    offerIQ,
+                    resolve,
+                    reject,
+                    /* local tracks */ []);
+            }).then(() => {
+                jingleSession.modifyContents(createContentModifyForSourceNames());
+                const v0Height = remoteSourcesRecvMaxFrameHeight[0].maxHeight;
+                const v1Height = remoteSourcesRecvMaxFrameHeight[1].maxHeight;
+
+                expect(v0Height).toBe('180');
+                expect(v1Height).toBe('2160');
+            });
+        });
+    });
 });

modules/xmpp/MediaSessionEvents.spec.ts

@@ -4,11 +4,13 @@ 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' );
     } );
 

modules/xmpp/MediaSessionEvents.ts

@@ -1,4 +1,9 @@
 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.
      */

types/auto/modules/qualitycontrol/ReceiveVideoController.d.ts

@@ -16,8 +16,22 @@ export default class ReceiveVideoController {
     _rtc: any;
     _lastN: any;
     _maxFrameHeight: number;
+    /**
+     * The map that holds the max frame height requested for each remote source when source-name signaling is
+     * enabled.
+     *
+     * @type Map<string, number>
+     */
+    _sourceReceiverConstraints: Map<string, number>;
     _receiverVideoConstraints: ReceiverVideoConstraints;
     _selectedEndpoints: any[];
+    /**
+     * Returns a map of all the remote source names and the corresponding max frame heights.
+     *
+     * @param {number} maxFrameHeight
+     * @returns
+     */
+    _getDefaultSourceReceiverConstraints(mediaSession: any, maxFrameHeight: number): Map<any, any>;
     /**
      * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
      * session. The preferred receive frameHeight is applied on the media session.

types/auto/modules/qualitycontrol/SendVideoController.d.ts

@@ -32,7 +32,7 @@ export default class SendVideoController {
     /**
      * Handles the {@link JitsiConferenceEvents.MEDIA_SESSION_STARTED}, that is when the conference creates new media
      * session. It doesn't mean it's already active though. For example the JVB connection may be created after
-     * the conference has entered the p2p mode already.
+-    * the conference has entered the p2p mode already.
      *
      * @param {JingleSessionPC} mediaSession - the started media session.
      * @private

types/auto/modules/xmpp/JingleSessionPC.d.ts

@@ -41,6 +41,14 @@ export default class JingleSessionPC extends JingleSession {
      * @returns {Number|null}
      */
     static parseMaxFrameHeight(jingleContents: any): number | null;
+    /**
+     * Parses the source-name and max frame height value of the 'content-modify' IQ when source-name signaling
+     * is enabled.
+     *
+     * @param {jQuery} jingleContents - A jQuery selector pointing to the '>jingle' element.
+     * @returns {Object|null}
+     */
+    static parseSourceMaxFrameHeight(jingleContents: any): any | null;
     /**
      * Creates new <tt>JingleSessionPC</tt>
      * @param {string} sid the Jingle Session ID - random string which identifies the session
@@ -106,6 +114,13 @@ export default class JingleSessionPC extends JingleSession {
      * @type {Number|undefined}
      */
     localRecvMaxFrameHeight: number | 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.
+     *
+     * @type {Map<string, number>}
+     */
+    _sourceReceiverConstraints: Map<string, number>;
     /**
      * Indicates whether or not this session is willing to send/receive
      * video media. When set to <tt>false</tt> the underlying peer
@@ -155,6 +170,12 @@ export default class JingleSessionPC extends JingleSession {
      * @type {Number|undefined}
      */
     remoteRecvMaxFrameHeight: number | undefined;
+    /**
+     * Remote preference for the receive video max frame heights when source-name signaling is enabled.
+     *
+     * @type {Map<string, number>|undefined}
+     */
+    remoteSourceMaxFrameHeights: Map<string, number> | undefined;
     /**
      * The queue used to serialize operations done on the peerconnection.
      *
@@ -204,6 +225,12 @@ export default class JingleSessionPC extends JingleSession {
      * @returns {Number|undefined}
      */
     getRemoteRecvMaxFrameHeight(): number | undefined;
+    /**
+     * Remote preference for receive video max frame heights when source-name signaling is enabled.
+     *
+     * @returns {Map<string, number>|undefined}
+     */
+    getRemoteSourcesRecvMaxFrameHeight(): Map<string, number> | undefined;
     /**
      * Sends given candidate in Jingle 'transport-info' message.
      * @param {RTCIceCandidate} candidate the WebRTC ICE candidate instance
@@ -327,8 +354,9 @@ export default class JingleSessionPC extends JingleSession {
      * the remote party.
      *
      * @param {Number} maxFrameHeight - the new value to set.
+     * @param {Map<string, number>} sourceReceiverConstraints - The receiver constraints per source.
      */
-    setReceiverVideoConstraint(maxFrameHeight: number): void;
+    setReceiverVideoConstraint(maxFrameHeight: number, sourceReceiverConstraints: Map<string, number>): void;
     /**
      * Sends Jingle 'transport-accept' message which is a response to
      * 'transport-replace'.

types/auto/modules/xmpp/MediaSessionEvents.d.ts

@@ -1,4 +1,8 @@
 declare 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.
      */