Apply max bitrate of 500Kbps on desktop streams and set the contentHint attribute on the track to 'detail'. (#992)

Enable/disable this feature using 'capScreenshareBitrate' testing flag in config.js and send analytics
events to Amplitude to indicate which type of screensharing is enabled.

JitsiMeetJS.js

                     }
                 }
 
+                // set the contentHint to "detail" for desktop tracks
+                // eslint-disable-next-line prefer-const
+                for (const track of tracks) {
+                    if (track.type === MediaType.VIDEO
+                        && track.videoType === 'desktop') {
+                        this.setVideoTrackContentHints(track.track, 'detail');
+                    }
+                }
+
                 return tracks;
             })
             .catch(error => {
         Statistics.reportGlobalError(error);
     },
 
+    /**
+     * Set the contentHint on the transmitted stream track to indicate
+     * charaterstics in the video stream, which informs PeerConnection
+     * on how to encode the track (to prefer motion or individual frame detail)
+     * @param {MediaStreamTrack} track - the track that is transmitted
+     * @param {String} hint - contentHint value that needs to be set on the track
+     */
+    setVideoTrackContentHints(track, hint) {
+        if ('contentHint' in track) {
+            track.contentHint = hint;
+            if (track.contentHint !== hint) {
+                logger.debug('Invalid video track contentHint');
+            }
+        } else {
+            logger.debug('MediaStreamTrack contentHint attribute not supported');
+        }
+    },
+
     /* eslint-enable max-params */
 
     /**

modules/RTC/TraceablePeerConnection.js

 const SIM_LAYER_2_RID = '2';
 const SIM_LAYER_3_RID = '3';
 const SIM_LAYER_RIDS = [ SIM_LAYER_1_RID, SIM_LAYER_2_RID, SIM_LAYER_3_RID ];
+const SIM_LAYER_BITRATES_BPS = [ 200000, 700000, 2500000 ];
+const DESKSTOP_SHARE_RATE = 500000;
 
 /* eslint-disable max-params */
 
  * @param {boolean} options.disableRtx if set to 'true' will disable the RTX
  * @param {boolean} options.enableFirefoxSimulcast if set to 'true' will enable
  * experimental simulcast support on Firefox.
+ * @param {boolean} options.capScreenshareBitrate if set to 'true' simulcast will
+ * be disabled for screenshare and a max bitrate of 500Kbps will applied on the
+ * stream.
  * @param {boolean} options.disableH264 If set to 'true' H264 will be
  *      disabled by removing it from the SDP.
  * @param {boolean} options.preferH264 if set to 'true' H264 will be preferred
         });
     };
 
+/**
+ * Sets the max bitrate on the RTCRtpSender so that the
+ * bitrate of the enocder doesn't exceed the configured value.
+ * This is needed for the desktop share until spec-complaint
+ * simulcast is implemented.
+ * @param {JitsiLocalTrack} localTrack - the local track whose
+ * max bitrate is to be configured.
+ */
+TraceablePeerConnection.prototype.setMaxBitRate = function(localTrack) {
+    const mediaType = localTrack.type;
+
+    if (!this.options.capScreenshareBitrate
+        || mediaType === MediaType.AUDIO) {
+
+        return;
+    }
+    if (!this.peerconnection.getSenders) {
+        logger.debug('Browser doesn\'t support RTCRtpSender');
+
+        return;
+    }
+    const videoType = localTrack.videoType;
+    const trackId = localTrack.track.id;
+
+    this.peerconnection.getSenders()
+        .filter(s => s.track && s.track.id === trackId)
+        .forEach(sender => {
+            try {
+                const parameters = sender.getParameters();
+
+                if (parameters.encodings && parameters.encodings.length) {
+                    logger.info('Setting max bitrate on video stream');
+                    for (const encoding in parameters.encodings) {
+                        if (parameters.encodings.hasOwnProperty(encoding)) {
+                            parameters.encodings[encoding].maxBitrate
+                                = videoType === 'desktop'
+                                    ? DESKSTOP_SHARE_RATE
+                                    : SIM_LAYER_BITRATES_BPS[encoding];
+                        }
+                    }
+                    sender.setParameters(parameters);
+                }
+            } catch (err) {
+                logger.error('Browser does not support getParameters/setParamters '
+                    + 'or setting max bitrate on the encodings: ', err);
+            }
+        });
+};
+
 TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
     return this._createOfferOrAnswer(true /* offer */, constraints);
 };
 
+/**
+ * Checks if a camera track has been added to the peerconnection
+ * @param {TraceablePeerConnection} peerConnection
+ * @return {boolean} <tt>true</tt> if the peerconnection has
+ * a camera track for its video source <tt>false</tt> otherwise.
+ */
+function hasCameraTrack(peerConnection) {
+    return peerConnection.getLocalTracks()
+        .some(t => t.videoType === 'camera');
+}
+
 TraceablePeerConnection.prototype._createOfferOrAnswer = function(
         isOffer,
         constraints) {
                     dumpSDP(resultSdp));
             }
 
-            // Add simulcast streams if simulcast is enabled
-            if (this.isSimulcastOn()) {
+            // configure simulcast for camera tracks always and for
+            // desktop tracks only when the testing flag for maxbitrates
+            // in config.js is disabled.
+            if (this.isSimulcastOn()
+                && (!this.options.capScreenshareBitrate
+                || (this.options.capScreenshareBitrate && hasCameraTrack(this)))) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.simulcast.mungeLocalDescription(resultSdp);
                 this.trace(
     if (ssrcInfo) {
         logger.error(`Will overwrite local SSRCs for track ID: ${rtcId}`);
     }
-    if (this.isSimulcastOn()) {
+
+    // configure simulcast for camera tracks always and for
+    // desktop tracks only when the testing flag for maxbitrates
+    // in config.js is disabled.
+    if (this.isSimulcastOn()
+        && (!this.options.capScreenshareBitrate
+        || (this.options.capScreenshareBitrate && hasCameraTrack(this)))) {
         ssrcInfo = {
             ssrcs: [],
             groups: []

modules/xmpp/JingleSessionPC.js

         if (options.gatherStats) {
             pcOptions.maxstats = DEFAULT_MAX_STATS;
         }
-
+        pcOptions.capScreenshareBitrate = false;
         if (this.isP2P) {
             // simulcast needs to be disabled for P2P (121) calls
             pcOptions.disableSimulcast = true;
             pcOptions.enableFirefoxSimulcast
                 = options.testing && options.testing.enableFirefoxSimulcast;
             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 (options.testing
+                && options.testing.capScreenshareBitrate
+                && typeof options.testing.capScreenshareBitrate === 'number') {
+                pcOptions.capScreenshareBitrate
+                    = Math.random()
+                    < options.testing.capScreenshareBitrate;
+            }
+        }
+
+        // send the corresponding amplitude events for simulcast screenshare
+        // and non-simulcast screenshare.
+        if (pcOptions.capScreenshareBitrate) {
+            Statistics.sendAnalyticsAndLog('nonSimulcastScreenSharing');
+        } else {
+            Statistics.sendAnalyticsAndLog('simulcastScreenSharing');
         }
 
         if (options.startSilent) {
 
             // NOTE the code below assumes that no more than 1 video track
             // can be added to the peer connection.
-            // Transition from no video to video (possibly screen sharing)
+            // Transition from camera to desktop share
+            // or transition from one camera source to another.
+            if (this.peerconnection.options.capScreenshareBitrate
+                && oldTrack && newTrack && newTrack.isVideoTrack()) {
+                // Clearing current primary SSRC will make
+                // the SdpConsistency generate a new one which will result
+                // with:
+                // 1. source-remove for the old video stream.
+                // 2. source-add for the new video stream.
+                this.peerconnection.clearRecvonlySsrc();
+            }
+
+            // Transition from no video to video (unmute).
             if (!oldTrack && newTrack && newTrack.isVideoTrack()) {
                 // Clearing current primary SSRC will make
                 // the SdpConsistency generate a new one which will result
 
                             this.notifyMySSRCUpdate(
                                 new SDP(oldLocalSdp), newLocalSDP);
+
+                            // configure max bitrate only when media is routed
+                            // through JVB. For p2p case, browser takes care of
+                            // adjusting the uplink based on the feedback it
+                            // gets from the peer.
+                            if (newTrack && !this.isP2P) {
+                                this.peerconnection.setMaxBitRate(newTrack);
+                            }
                             finishedCallback();
                         },
                         finishedCallback /* will be called with en error */);