feat(p2p): real "audio only" mode

When the lastN is set to 0 the P2P session will notify the remote peer
to stop sending video.

JitsiConference.js

@@ -953,6 +953,20 @@ JitsiConference.prototype.setLastN = function(lastN) {
         throw new RangeError('lastN cannot be smaller than -1');
     }
     this.rtc.setLastN(n);
+
+    // If the P2P session is not fully established yet, we wait until it gets
+    // established.
+    if (this.p2pJingleSession) {
+        const isVideoActive = n !== 0;
+
+        this.p2pJingleSession
+            .setMediaTransferActive(true, isVideoActive)
+            .catch(error => {
+                logger.error(
+                    `Failed to adjust video transfer status (${isVideoActive})`,
+                    error);
+            });
+    }
 };
 
 /**
@@ -2076,7 +2090,7 @@ JitsiConference.prototype._removeRemoteTracks
  */
 JitsiConference.prototype._resumeMediaTransferForJvbConnection = function() {
     logger.info('Resuming media transfer over the JVB connection...');
-    this.jvbJingleSession.setMediaTransferActive(true).then(
+    this.jvbJingleSession.setMediaTransferActive(true, true).then(
         () => {
             logger.info('Resumed media transfer over the JVB connection!');
         },
@@ -2103,6 +2117,18 @@ JitsiConference.prototype._setP2PStatus = function(newStatus) {
     this.p2p = newStatus;
     if (newStatus) {
         logger.info('Peer to peer connection established!');
+
+        // Sync up video transfer active in case p2pJingleSession not existed
+        // when the lastN value was being adjusted.
+        const isVideoActive = this.rtc.getLastN() !== 0;
+
+        this.p2pJingleSession
+            .setMediaTransferActive(true, isVideoActive)
+            .catch(error => {
+                logger.error(
+                    'Failed to sync up P2P video transfer status'
+                        + `(${isVideoActive})`, error);
+            });
     } else {
         logger.info('Peer to peer connection closed!');
     }
@@ -2172,7 +2198,7 @@ JitsiConference.prototype._startP2PSession = function(peerJid) {
  */
 JitsiConference.prototype._suspendMediaTransferForJvbConnection = function() {
     logger.info('Suspending media transfer over the JVB connection...');
-    this.jvbJingleSession.setMediaTransferActive(false).then(
+    this.jvbJingleSession.setMediaTransferActive(false, false).then(
         () => {
             logger.info('Suspended media transfer over the JVB connection !');
         },

modules/RTC/TraceablePeerConnection.js

@@ -60,13 +60,23 @@ export default function TraceablePeerConnection(
 
     /**
      * Indicates whether or not this peer connection instance is actively
-     * sending/receiving media. When set to <tt>false</tt> the SDP media
-     * direction will be adjusted to 'inactive' in order to suspend media
-     * transmission.
+     * sending/receiving audio media. When set to <tt>false</tt> the SDP audio
+     * media direction will be adjusted to 'inactive' in order to suspend
+     * the transmission.
      * @type {boolean}
      * @private
      */
-    this.mediaTransferActive = true;
+    this.audioTransferActive = true;
+
+    /**
+     * Indicates whether or not this peer connection instance is actively
+     * sending/receiving video media. When set to <tt>false</tt> the SDP video
+     * media direction will be adjusted to 'inactive' in order to suspend
+     * the transmission.
+     * @type {boolean}
+     * @private
+     */
+    this.videoTransferActive = true;
 
     /**
      * The parent instance of RTC service which created this
@@ -319,7 +329,7 @@ TraceablePeerConnection.prototype.getConnectionState = function() {
 /**
  * Obtains the media direction for given {@link MediaType}. The method takes
  * into account whether or not there are any local tracks for media and
- * the {@link mediaTransferActive} flag.
+ * the {@link audioTransferActive} and {@link videoTransferActive} flags.
  * @param {MediaType} mediaType
  * @return {string} one of the SDP direction constants ('sendrecv, 'recvonly'
  * etc.) which should be used when setting local description on the peer
@@ -328,7 +338,14 @@ TraceablePeerConnection.prototype.getConnectionState = function() {
  */
 TraceablePeerConnection.prototype._getDesiredMediaDirection
 = function(mediaType) {
-    if (this.mediaTransferActive) {
+    let mediaTransferActive = true;
+
+    if (mediaType === MediaType.AUDIO) {
+        mediaTransferActive = this.audioTransferActive;
+    } else if (mediaType === MediaType.VIDEO) {
+        mediaTransferActive = this.videoTransferActive;
+    }
+    if (mediaTransferActive) {
         return this.hasAnyTracksOfType(mediaType) ? 'sendrecv' : 'recvonly';
     }
 
@@ -1369,7 +1386,8 @@ TraceablePeerConnection.prototype._ensureSimulcastGroupIsLast
 
 /**
  * Will adjust audio and video media direction in the given SDP object to
- * reflect the current status of the {@link mediaTransferActive} flag.
+ * reflect the current status of the {@link audioTransferActive} and
+ * {@link videoTransferActive} flags.
  * @param {Object} localDescription the WebRTC session description instance for
  * the local description.
  * @private
@@ -1456,16 +1474,25 @@ TraceablePeerConnection.prototype.setLocalDescription
 };
 
 /**
- * Enables/disables media transmission on this peer connection. When disabled
- * the SDP media direction in the local SDP will be adjusted to 'inactive' which
- * means that no data will be received or sent, but the connection should be
- * kept alive.
- * @param {boolean} active <tt>true</tt> to enable the media transmission or
- * <tt>false</tt> to disable.
+ * Enables/disables audio media transmission on this peer connection. When
+ * disabled the SDP audio media direction in the local SDP will be adjusted to
+ * 'inactive' which means that no data will be sent nor accepted, but
+ * the connection should be kept alive.
+ * @param {boolean} active <tt>true</tt> to enable video media transmission or
+ * <tt>false</tt> to disable. If the value is not a boolean the call will have
+ * no effect.
+ * @return {boolean} <tt>true</tt> if the value has changed and sRD/sLD cycle
+ * needs to be executed in order for the changes to take effect or
+ * <tt>false</tt> if the given value was the same as the previous one.
  * @public
  */
-TraceablePeerConnection.prototype.setMediaTransferActive = function(active) {
-    this.mediaTransferActive = active;
+TraceablePeerConnection.prototype.setAudioTransferActive = function(active) {
+    logger.debug(`${this} audio transfer active: ${active}`);
+    const changed = this.audioTransferActive !== active;
+
+    this.audioTransferActive = active;
+
+    return changed;
 };
 
 TraceablePeerConnection.prototype.setRemoteDescription
@@ -1528,6 +1555,28 @@ TraceablePeerConnection.prototype.setRemoteDescription
         });
 };
 
+/**
+ * Enables/disables video media transmission on this peer connection. When
+ * disabled the SDP video media direction in the local SDP will be adjusted to
+ * 'inactive' which means that no data will be sent nor accepted, but
+ * the connection should be kept alive.
+ * @param {boolean} active <tt>true</tt> to enable video media transmission or
+ * <tt>false</tt> to disable. If the value is not a boolean the call will have
+ * no effect.
+ * @return {boolean} <tt>true</tt> if the value has changed and sRD/sLD cycle
+ * needs to be executed in order for the changes to take effect or
+ * <tt>false</tt> if the given value was the same as the previous one.
+ * @public
+ */
+TraceablePeerConnection.prototype.setVideoTransferActive = function(active) {
+    logger.debug(`${this} video transfer active: ${active}`);
+    const changed = this.videoTransferActive !== active;
+
+    this.videoTransferActive = active;
+
+    return changed;
+};
+
 /**
  * Makes the underlying TraceablePeerConnection generate new SSRC for
  * the recvonly video stream.

modules/xmpp/JingleSessionPC.js

@@ -25,6 +25,30 @@ const IQ_TIMEOUT = 10000;
  *
  */
 export default class JingleSessionPC extends JingleSession {
+    /**
+     * Parses 'senders' attribute of the video content.
+     * @param {jQuery} jingleContents
+     * @return {string|null} one of the values of content "senders" attribute
+     * defined by Jingle. If there is no "senders" attribute or if the value is
+     * invalid then <tt>null</tt> will be returned.
+     * @private
+     */
+    static parseVideoSenders(jingleContents) {
+        const videoContents = jingleContents.find('>content[name="video"]');
+
+        if (videoContents.length) {
+            const senders = videoContents[0].getAttribute('senders');
+
+            if (senders === 'both'
+                || senders === 'initiator'
+                || senders === 'responder'
+                || senders === 'none') {
+                return senders;
+            }
+        }
+
+        return null;
+    }
 
     /* eslint-disable max-params */
 
@@ -89,6 +113,34 @@ export default class JingleSessionPC extends JingleSession {
          */
         this._gatheringStartedTimestamp = null;
 
+        /**
+         * Indicates whether or not this session is willing to send/receive
+         * video media. When set to <tt>false</tt> the underlying peer
+         * connection will disable local video transfer and the remote peer will
+         * be will be asked to stop sending video via 'content-modify' IQ
+         * (the senders attribute of video contents will be adjusted
+         * accordingly). Note that this notification is sent only in P2P
+         * session, because Jicofo does not support it yet. Obviously when
+         * the value is changed from <tt>false</tt> to <tt>true</tt> another
+         * notification will be sent to resume video transfer on the remote
+         * side.
+         * @type {boolean}
+         * @private
+         */
+        this._localVideoActive = true;
+
+        /**
+         * Indicates whether or not the remote peer has video transfer active.
+         * When set to <tt>true</tt> it means that remote peer is neither
+         * sending nor willing to receive video. In such case we'll ask
+         * our peerconnection to stop sending video by calling
+         * {@link TraceablePeerConnection.setVideoTransferActive} with
+         * <tt>false</tt>.
+         * @type {boolean}
+         * @private
+         */
+        this._remoteVideoActive = true;
+
         /**
          * Marks that ICE gathering duration has been reported already. That
          * prevents reporting it again, after eventual 'transport-replace' (JVB
@@ -116,16 +168,6 @@ export default class JingleSessionPC extends JingleSession {
          */
         this.isP2P = isP2P;
 
-        /**
-         * Stores a state for
-         * {@link TraceablePeerConnection.mediaTransferActive} until
-         * {@link JingleSessionPC.peerconnection} is initialised and capable of
-         * handling the value.
-         * @type {boolean}
-         * @private
-         */
-        this.mediaTransferActive = true;
-
         /**
          * The signaling layer implementation.
          * @type {SignalingLayerImpl}
@@ -232,8 +274,6 @@ export default class JingleSessionPC extends JingleSession {
                     preferH264: this.room.options.preferH264
                 });
 
-        this.peerconnection.setMediaTransferActive(this.mediaTransferActive);
-
         this.peerconnection.onicecandidate = ev => {
             if (!ev) {
                 // There was an incomplete check for ev before which left
@@ -831,6 +871,21 @@ export default class JingleSessionPC extends JingleSession {
                 .then(() => {
                     if (this.state === JingleSessionState.PENDING) {
                         this.state = JingleSessionState.ACTIVE;
+
+                        // Sync up video transfer active/inactive only after
+                        // the initial O/A cycle. We want to adjust the video
+                        // media direction only in the local SDP and the Jingle
+                        // contents direction included in the initial
+                        // offer/answer is mapped to the remote SDP. Jingle
+                        // 'content-modify' IQ is processed in a way that it
+                        // will only modify local SDP when remote peer is no
+                        // longer interested in receiving video content.
+                        // Changing media direction in the remote SDP will mess
+                        // up our SDP translation chain (simulcast, video mute,
+                        // RTX etc.)
+                        if (this.isP2P && !this._localVideoActive) {
+                            this.sendContentModify(this._localVideoActive);
+                        }
                     }
 
                     // Old local SDP will be available when we're setting answer
@@ -973,6 +1028,44 @@ export default class JingleSessionPC extends JingleSession {
         // this.connection.flush();
     }
 
+    /**
+     * Will send 'content-modify' IQ in order to ask the remote peer to
+     * either stop or resume sending video media.
+     * @param {boolean} videoTransferActive <tt>false</tt> to let the other peer
+     * know that we're not sending nor interested in receiving video contents.
+     * When set to <tt>true</tt> remote peer will be asked to resume video
+     * transfer.
+     * @private
+     */
+    sendContentModify(videoTransferActive) {
+        const newSendersValue = videoTransferActive ? 'both' : 'none';
+
+        const sessionModify
+            = $iq({
+                to: this.peerjid,
+                type: 'set'
+            })
+            .c('jingle', {
+                xmlns: 'urn:xmpp:jingle:1',
+                action: 'content-modify',
+                initiator: this.initiator,
+                sid: this.sid
+            })
+            .c('content', {
+                name: 'video',
+                senders: newSendersValue
+            });
+
+        logger.info(
+            `Sending content-modify, video senders: ${newSendersValue}`);
+
+        this.connection.sendIQ(
+            sessionModify,
+            null,
+            this.newJingleErrorHandler(sessionModify),
+            IQ_TIMEOUT);
+    }
+
     /**
      * Sends Jingle 'transport-accept' message which is a response to
      * 'transport-replace'.
@@ -1747,31 +1840,60 @@ export default class JingleSessionPC extends JingleSession {
 
     /**
      * Resumes or suspends media transfer over the underlying peer connection.
-     * @param {boolean} active <tt>true</tt> to enable media transfer or
-     * <tt>false</tt> to suspend any media transmission.
+     * @param {boolean} audioActive <tt>true</tt> to enable audio media
+     * transfer or <tt>false</tt> to suspend audio media transmission.
+     * @param {boolean} videoActive <tt>true</tt> to enable video media
+     * transfer or <tt>false</tt> to suspend video media transmission.
      * @return {Promise} a <tt>Promise</tt> which will resolve once
      * the operation is done. It will be rejected with an error description as
      * a string in case anything goes wrong.
      */
-    setMediaTransferActive(active) {
+    setMediaTransferActive(audioActive, videoActive) {
+        if (!this.peerconnection) {
+            return Promise.reject(
+                'Can not modify transfer active state,'
+                    + ' before "initialize" is called');
+        }
+
+        const logAudioStr = audioActive ? 'audio active' : 'audio inactive';
+        const logVideoStr = videoActive ? 'video active' : 'video inactive';
+
+        logger.info(`Queued make ${logVideoStr}, ${logAudioStr} task...`);
+
         const workFunction = finishedCallback => {
+            const isSessionActive = this.state === JingleSessionState.ACTIVE;
 
             // Because the value is modified on the queue it's impossible to
             // check it's final value reliably prior to submitting the task.
             // The rule here is that the last submitted state counts.
-            // Check the value here to avoid unnecessary renegotiation cycle.
-            if (this.mediaTransferActive === active) {
-                finishedCallback();
-
-                return;
+            // Check the values here to avoid unnecessary renegotiation cycle.
+            const audioActiveChanged
+                = this.peerconnection.setAudioTransferActive(audioActive);
+
+            if (this._localVideoActive !== videoActive) {
+                this._localVideoActive = videoActive;
+
+                // Do only for P2P - Jicofo will reply with 'bad-request'
+                // We don't want to send 'content-modify', before the initial
+                // O/A (state === JingleSessionState.ACTIVE), because that will
+                // mess up video media direction in the remote SDP.
+                // 'content-modify' when processed only affects the media
+                // direction in the local SDP. We're doing that, because setting
+                // 'inactive' on video media in remote SDP will mess up our SDP
+                // translation chain (simulcast, RTX, video mute etc.).
+                if (this.isP2P && isSessionActive) {
+                    this.sendContentModify(videoActive);
+                }
             }
-            this.mediaTransferActive = active;
-            if (this.peerconnection) {
-                this.peerconnection.setMediaTransferActive(
-                    this.mediaTransferActive);
 
-                // Will do the sRD/sLD cycle to update SDPs and adjust the media
-                // direction
+            const pcVideoActiveChanged
+                = this.peerconnection.setVideoTransferActive(
+                    this._localVideoActive && this._remoteVideoActive);
+
+            // Will do the sRD/sLD cycle to update SDPs and adjust the media
+            // direction
+            if (isSessionActive
+                    && (audioActiveChanged || pcVideoActiveChanged)) {
                 this._renegotiate()
                     .then(
                         finishedCallback,
@@ -1781,10 +1903,6 @@ export default class JingleSessionPC extends JingleSession {
             }
         };
 
-        const logStr = active ? 'active' : 'inactive';
-
-        logger.info(`Queued make media transfer ${logStr} task...`);
-
         return new Promise((resolve, reject) => {
             this.modificationQueue.push(
                 workFunction,
@@ -1798,6 +1916,79 @@ export default class JingleSessionPC extends JingleSession {
         });
     }
 
+    /**
+     * Will put and execute on the queue a session modify task. Currently it
+     * only checks the senders attribute of the video content in order to figure
+     * out if the remote peer has video in the inactive state (stored locally
+     * in {@link _remoteVideoActive} - see field description for more info).
+     * @param {jQuery} jingleContents jQuery selector pointing to the jingle
+     * element of the session modify IQ.
+     * @see {@link _remoteVideoActive}
+     * @see {@link _localVideoActive}
+     */
+    modifyContents(jingleContents) {
+        const newVideoSenders
+            = JingleSessionPC.parseVideoSenders(jingleContents);
+
+        if (newVideoSenders === null) {
+            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
+                this._renegotiate()
+                    .then(finishedCallback, finishedCallback /* (error) */);
+            } else {
+                finishedCallback();
+            }
+        };
+
+        logger.debug(
+            `${this} queued "content-modify" task`
+                + `(video senders="${newVideoSenders}")`);
+
+        this.modificationQueue.push(
+            workFunction,
+            error => {
+                if (error) {
+                    logger.error('"content-modify" failed', error);
+                }
+            });
+    }
+
+    /**
+     * Processes new value of remote video "senders" Jingle attribute and tries
+     * to apply it for {@link _remoteVideoActive}.
+     * @param {string} remoteVideoSenders the value of "senders" attribute of
+     * Jingle video content element advertised by remote peer.
+     * @return {boolean} <tt>true</tt> if the change affected state of
+     * the underlying peerconnection and renegotiation is required for
+     * the changes to take effect.
+     * @private
+     */
+    _modifyRemoteVideoActive(remoteVideoSenders) {
+        const isRemoteVideoActive
+            = remoteVideoSenders === 'both'
+                || (remoteVideoSenders === 'initiator' && this.isInitiator)
+                || (remoteVideoSenders === 'responder' && !this.isInitiator);
+
+        if (isRemoteVideoActive !== this._remoteVideoActive) {
+            logger.debug(
+                `${this} new remote video active: ${isRemoteVideoActive}`);
+            this._remoteVideoActive = isRemoteVideoActive;
+        }
+
+        return this.peerconnection.setVideoTransferActive(
+            this._localVideoActive && this._remoteVideoActive);
+    }
+
     /**
      * Figures out added/removed ssrcs and send update IQs.
      * @param oldSDP SDP object for old description.

modules/xmpp/strophe.jingle.js

@@ -172,6 +172,10 @@ class JingleConnectionPlugin extends ConnectionPlugin {
                 XMPPEvents.CALL_ACCEPTED, sess, $(iq).find('>jingle'));
             break;
         }
+        case 'content-modify': {
+            sess.modifyContents($(iq).find('>jingle'));
+            break;
+        }
         case 'transport-info': {
             this.eventEmitter.emit(
                 XMPPEvents.TRANSPORT_INFO, sess, $(iq).find('>jingle'));