feat(RTC): Add the ability to change desktop share fps.

Provide a method for changing the capture fps for desktop tracks during the call. These changes to the lib are needed for making it configurable from the UI.

JitsiConference.js

     return null;
 };
 
+/**
+ * Configures the peerconnection so that a given framre rate can be achieved for desktop share.
+ *
+ * @param {number} maxFps The capture framerate to be used for desktop tracks.
+ * @returns {boolean} true if the operation is successful, false otherwise.
+ */
+JitsiConference.prototype.setDesktopSharingFrameRate = function(maxFps) {
+    if (typeof maxFps !== 'number' || isNaN(maxFps)) {
+        logger.error(`Invalid value ${maxFps} specified for desktop capture frame rate`);
+
+        return false;
+    }
+
+    // Enable or disable simulcast for plan-b screensharing based on the capture fps.
+    this.jvbJingleSession && this.jvbJingleSession.peerconnection.setDesktopSharingFrameRate(maxFps);
+
+    // Set the capture rate for desktop sharing.
+    this.rtc.setDesktopSharingFrameRate(maxFps);
+
+    return true;
+};
 
 /**
  * Manually starts new P2P session (should be used only in the tests).

modules/RTC/RTC.js

     static obtainAudioAndVideoPermissions(options) {
         return RTCUtils.obtainAudioAndVideoPermissions(options)
             .then(tracksInfo => _createLocalTracks(tracksInfo));
-
     }
 
     /**
         }
     }
 
+    /**
+     * Sets the capture frame rate to be used for desktop tracks.
+     *
+     * @param {number} maxFps framerate to be used for desktop track capture.
+     */
+    setDesktopSharingFrameRate(maxFps) {
+        RTCUtils.setDesktopSharingFrameRate(maxFps);
+    }
+
     /**
      * Sets the receiver video constraints that determine how bitrate is allocated to each of the video streams
      * requested from the bridge. The constraints are cached and sent through the bridge channel once the channel

modules/RTC/RTCUtils.js

             });
     }
 
+    /**
+     * Sets the capture frame rate for desktop tracks.
+     *
+     * @param {number} maxFps - max fps to be used as the capture frame rate.
+     * @returns {void}
+     */
+    setDesktopSharingFrameRate(maxFps) {
+        screenObtainer.setDesktopSharingFrameRate(maxFps);
+    }
+
     /**
      * Returns currently used audio output device id, '' stands for default
      * device

modules/RTC/ScreenObtainer.js

                 errorCallback(new JitsiTrackError(JitsiTrackErrors
                     .SCREENSHARING_USER_CANCELED));
             });
+    },
+
+    /**
+     * Sets the max frame rate to be used for a desktop track capture.
+     *
+     * @param {number} maxFps capture frame rate to be used for desktop tracks.
+     * @returns {void}
+     */
+    setDesktopSharingFrameRate(maxFps) {
+        logger.info(`Setting the desktop capture rate to ${maxFps}`);
+
+        this.options.desktopSharingFrameRate = {
+            min: SS_DEFAULT_FRAME_RATE,
+            max: maxFps
+        };
     }
 };
 

modules/RTC/TraceablePeerConnection.js

 import RTCEvents from '../../service/RTC/RTCEvents';
 import * as SignalingEvents from '../../service/RTC/SignalingEvents';
 import * as VideoType from '../../service/RTC/VideoType';
+import { SS_DEFAULT_FRAME_RATE } from '../RTC/ScreenObtainer';
 import browser from '../browser';
 import LocalSdpMunger from '../sdp/LocalSdpMunger';
 import RtxModifier from '../sdp/RtxModifier';
     this.stats = {};
     this.statsinterval = null;
 
+    /**
+     * Flag used to indicate if simulcast is turned off and a cap of 500 Kbps is applied on screensharing.
+     */
+    this._capScreenshareBitrate = this.options.capScreenshareBitrate;
+
     /**
     * Flag used to indicate if the browser is running in unified  plan mode.
     */
     return defaultCodec;
 };
 
+/**
+ * Enables or disables simulcast for screenshare based on the frame rate requested for desktop track capture.
+ *
+ * @param {number} maxFps framerate to be used for desktop track capture.
+ */
+TraceablePeerConnection.prototype.setDesktopSharingFrameRate = function(maxFps) {
+    const lowFps = maxFps <= SS_DEFAULT_FRAME_RATE;
+
+    this._capScreenshareBitrate = this.isSimulcastOn() && lowFps && !this._usesUnifiedPlan;
+};
+
 /**
  * Sets the codec preference on the peerconnection. The codec preference goes into effect when
  * the next renegotiation happens.
     const parameters = videoSender.getParameters();
     const preference = localVideoTrack.videoType === VideoType.CAMERA
         ? DEGRADATION_PREFERENCE_CAMERA
-        : this.options.capScreenshareBitrate && !this._usesUnifiedPlan
+        : this._capScreenshareBitrate && !this._usesUnifiedPlan
 
             // Prefer resolution for low fps share.
             ? DEGRADATION_PREFERENCE_DESKTOP
     // 2. Track is a desktop track and bitrate is capped using capScreenshareBitrate option in plan-b mode.
     // 3. The client is running in Unified plan mode.
     if (!((this.options.videoQuality && this.options.videoQuality.maxBitratesVideo)
-        || (planBScreenSharing && this.options.capScreenshareBitrate)
+        || (planBScreenSharing && this._capScreenshareBitrate)
         || this._usesUnifiedPlan)) {
         return Promise.resolve();
     }
                     // is enabled through config.js and presenter is not turned on.
                     // FIXME the top 'isSimulcastOn' condition is confusing for screensharing, because
                     // if capScreenshareBitrate option is enabled then the simulcast is turned off
-                    bitrate = this.options.capScreenshareBitrate
+                    bitrate = this._capScreenshareBitrate
                         ? presenterEnabled ? HD_BITRATE : DESKTOP_SHARE_RATE
 
                         // Remove the bitrate config if not capScreenshareBitrate:
             // Configure simulcast for camera tracks always and for desktop tracks only when
             // the "capScreenshareBitrate" flag in config.js is disabled.
             if (this.isSimulcastOn() && browser.usesSdpMungingForSimulcast()
-                && (!this.options.capScreenshareBitrate
-                || (this.options.capScreenshareBitrate && !this._isSharingScreen()))) {
+                && (!this._capScreenshareBitrate
+                || (this._capScreenshareBitrate && !this._isSharingScreen()))) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.simulcast.mungeLocalDescription(resultSdp);
                 this.trace(
     // Configure simulcast for camera tracks always and for desktop tracks only when
     // the "capScreenshareBitrate" flag in config.js is disabled.
     if (this.isSimulcastOn()
-        && (!this.options.capScreenshareBitrate
-        || (this.options.capScreenshareBitrate && !this._isSharingScreen()))) {
+        && (!this._capScreenshareBitrate
+        || (this._capScreenshareBitrate && !this._isSharingScreen()))) {
         ssrcInfo = {
             ssrcs: [],
             groups: []