feat(chrome|safari): stop the video for maxFrameHeight 0

modules/RTC/TraceablePeerConnection.js

@@ -2221,17 +2221,22 @@ TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
  * successful and rejected otherwise.
  */
 TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeight = null) {
+    if (frameHeight < 0) {
+        throw new Error(`Invalid frameHeight: ${frameHeight}`);
+    }
+
     // XXX: This is not yet supported on mobile.
     if (browser.isReactNative()) {
         return Promise.resolve();
     }
 
-    const newHeight = frameHeight || this.senderVideoMaxHeight;
+    // Need to explicitly check for null as 0 is falsy, but a valid value
+    const newHeight = frameHeight === null ? this.senderVideoMaxHeight : frameHeight;
 
     this.senderVideoMaxHeight = newHeight;
-    if (!newHeight) {
-        return Promise.resolve();
-    }
+
+    logger.log(`${this} senderVideoMaxHeight: ${newHeight}`);
+
     const localVideoTrack = this.getLocalVideoTrack();
 
     if (!localVideoTrack || localVideoTrack.isMuted() || localVideoTrack.videoType !== VideoType.CAMERA) {
@@ -2247,7 +2252,6 @@ TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeigh
     if (!parameters || !parameters.encodings || !parameters.encodings.length) {
         return Promise.reject(new Error('RTCRtpSendParameters not found for local video track'));
     }
-    logger.info(`Setting max height of ${newHeight} on local video`);
 
     if (this.isSimulcastOn()) {
         // Determine the encodings that need to stay enabled based on the
@@ -2260,10 +2264,16 @@ TraceablePeerConnection.prototype.setSenderVideoConstraint = function(frameHeigh
                 parameters.encodings[encoding].active = encodingsEnabledState[encoding];
             }
         }
-    } else if (localVideoTrack.resolution > newHeight) {
+    } else if (newHeight > 0) {
         parameters.encodings[0].scaleResolutionDownBy = Math.floor(localVideoTrack.resolution / newHeight);
+        parameters.encodings[0].active = true;
+    } else {
+        parameters.encodings[0].scaleResolutionDownBy = undefined;
+        parameters.encodings[0].active = false;
     }
 
+    logger.info(`${this} setting max height of ${newHeight}, encodings: ${JSON.stringify(parameters.encodings)}`);
+
     return videoSender.setParameters(parameters).then(() => {
         localVideoTrack.maxEnabledResolution = newHeight;
         this.eventEmitter.emit(RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED, localVideoTrack);

modules/qualitycontrol/QualityController.js

@@ -62,12 +62,10 @@ export class QualityController {
         const sendMaxFrameHeight = this.selectSendMaxFrameHeight();
         const promises = [];
 
-        if (!sendMaxFrameHeight) {
-            return Promise.resolve();
-        }
-
-        for (const session of this.conference._getMediaSessions()) {
-            promises.push(session.setSenderVideoConstraint(sendMaxFrameHeight));
+        if (sendMaxFrameHeight >= 0) {
+            for (const session of this.conference._getMediaSessions()) {
+                promises.push(session.setSenderVideoConstraint(sendMaxFrameHeight));
+            }
         }
 
         return Promise.all(promises);
@@ -83,9 +81,9 @@ export class QualityController {
         const activeMediaSession = this.conference._getActiveMediaSession();
         const remoteRecvMaxFrameHeight = activeMediaSession && activeMediaSession.getRemoteRecvMaxFrameHeight();
 
-        if (this.preferredSendMaxFrameHeight && remoteRecvMaxFrameHeight) {
+        if (this.preferredSendMaxFrameHeight >= 0 && remoteRecvMaxFrameHeight >= 0) {
             return Math.min(this.preferredSendMaxFrameHeight, remoteRecvMaxFrameHeight);
-        } else if (remoteRecvMaxFrameHeight) {
+        } else if (remoteRecvMaxFrameHeight >= 0) {
             return remoteRecvMaxFrameHeight;
         }
 

modules/qualitycontrol/QualityController.spec.js

@@ -0,0 +1,134 @@
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import Listenable from '../util/Listenable';
+import MediaSessionEvents from '../xmpp/MediaSessionEvents';
+
+import { QualityController } from './QualityController';
+
+// JSDocs disabled for Mock classes to avoid duplication - check on the original classes for info.
+/* eslint-disable require-jsdoc */
+/**
+ * A mock JingleSessionPC impl that fit the needs of the QualityController module.
+ * Should a generic, shared one exist in the future this test file should switch to use it too.
+ */
+class MockJingleSessionPC extends Listenable {
+    constructor() {
+        super();
+        this._remoteRecvMaxFrameHeight = undefined;
+        this.senderVideoConstraint = undefined;
+    }
+
+    getRemoteRecvMaxFrameHeight() {
+        return this._remoteRecvMaxFrameHeight;
+    }
+
+    // eslint-disable-next-line no-empty-function
+    setSenderVideoDegradationPreference() {
+
+    }
+
+    // eslint-disable-next-line no-empty-function
+    setSenderMaxBitrates() {
+
+    }
+
+    setSenderVideoConstraint(senderVideoConstraint) {
+        this.senderVideoConstraint = senderVideoConstraint;
+    }
+
+    setRemoteRecvMaxFrameHeight(remoteRecvMaxFrameHeight) {
+        this._remoteRecvMaxFrameHeight = remoteRecvMaxFrameHeight;
+        this.eventEmitter.emit(
+            MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
+            this);
+    }
+}
+
+/**
+ * Mock conference for the purpose of this test file.
+ */
+class MockConference extends Listenable {
+    /**
+     * A constructor...
+     */
+    constructor() {
+        super();
+        this.options = {
+            config: { }
+        };
+        this.activeMediaSession = undefined;
+        this.mediaSessions = [];
+    }
+
+    addMediaSession(mediaSession) {
+        this.mediaSessions.push(mediaSession);
+
+        this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_STARTED, mediaSession);
+    }
+
+    setActiveMediaSession(mediaSession) {
+        if (this.mediaSessions.indexOf(mediaSession) === -1) {
+            throw new Error('Given session is not part of this conference');
+        }
+
+        this.activeMediaSession = mediaSession;
+
+        this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, this.activeMediaSession);
+    }
+
+    _getActiveMediaSession() {
+        return this.activeMediaSession;
+    }
+
+    _getMediaSessions() {
+        return this.mediaSessions;
+    }
+}
+/* eslint-enable require-jsdoc */
+
+describe('QualityController', () => {
+    let conference;
+    let qualityController;
+    let jvbConnection;
+    let p2pConnection;
+
+    beforeEach(() => {
+        conference = new MockConference();
+        qualityController = new QualityController(conference);
+        jvbConnection = new MockJingleSessionPC();
+        p2pConnection = new MockJingleSessionPC();
+
+        conference.addMediaSession(jvbConnection);
+        conference.addMediaSession(p2pConnection);
+    });
+    describe('handles 0 as receiver/sender video constraint', () => {
+        it('0 if it\'s the active sessions\'s remote recv constraint', () => {
+            jvbConnection.setRemoteRecvMaxFrameHeight(0);
+            p2pConnection.setRemoteRecvMaxFrameHeight(720);
+
+            conference.setActiveMediaSession(jvbConnection);
+
+            expect(jvbConnection.senderVideoConstraint).toBe(0);
+            expect(p2pConnection.senderVideoConstraint).toBe(0);
+        });
+        it('720 if 0 is set on the non-active session', () => {
+            jvbConnection.setRemoteRecvMaxFrameHeight(0);
+            p2pConnection.setRemoteRecvMaxFrameHeight(720);
+
+            conference.setActiveMediaSession(p2pConnection);
+
+            expect(jvbConnection.senderVideoConstraint).toBe(720);
+            expect(p2pConnection.senderVideoConstraint).toBe(720);
+        });
+        it('0 if it\'s the local send preference while remote are 720', () => {
+            conference.setActiveMediaSession(p2pConnection);
+
+            jvbConnection.setRemoteRecvMaxFrameHeight(720);
+            p2pConnection.setRemoteRecvMaxFrameHeight(720);
+
+            qualityController.setPreferredSendMaxFrameHeight(0);
+
+            expect(jvbConnection.senderVideoConstraint).toBe(0);
+            expect(p2pConnection.senderVideoConstraint).toBe(0);
+        });
+    });
+});