fix(unified-plan): use RTCRtpSender.replaceTrack for mute/unmute/replace operations

Trigger renegotation only when negotiationneeded event is fired on the browser.
Do not disable simulcast for screensharing in unified plan.
Fix the order of the simulcast streams for Firefox

modules/RTC/TPCUtils.js

+import { getLogger } from 'jitsi-meet-logger';
+import transform from 'sdp-transform';
+
+import * as JitsiTrackEvents from '../../JitsiTrackEvents';
+import browser from '../browser';
+import RTCEvents from '../../service/RTC/RTCEvents';
+
+const logger = getLogger(__filename);
+const SIM_LAYER_1_RID = '1';
+const SIM_LAYER_2_RID = '2';
+const SIM_LAYER_3_RID = '3';
+
+export const SIM_LAYER_RIDS = [ SIM_LAYER_1_RID, SIM_LAYER_2_RID, SIM_LAYER_3_RID ];
+
+/**
+ * Handles track related operations on TraceablePeerConnection when browser is
+ * running in unified plan mode.
+ */
+export class TPCUtils {
+    /**
+     * @constructor
+     */
+    constructor(peerconnection) {
+        this.pc = peerconnection;
+
+        /**
+         * The simulcast encodings that will be configured on the RTCRtpSender
+         * for the video tracks in the unified plan mode.
+         */
+        this.simulcastEncodings = [
+            {
+                active: true,
+                maxBitrate: browser.isFirefox() ? 2500000 : 200000,
+                rid: SIM_LAYER_1_RID,
+                scaleResolutionDownBy: browser.isFirefox() ? 1.0 : 4.0
+            },
+            {
+                active: true,
+                maxBitrate: 700000,
+                rid: SIM_LAYER_2_RID,
+                scaleResolutionDownBy: 2.0
+            },
+            {
+                active: true,
+                maxBitrate: browser.isFirefox() ? 200000 : 2500000,
+                rid: SIM_LAYER_3_RID,
+                scaleResolutionDownBy: browser.isFirefox() ? 4.0 : 1.0
+            }
+        ];
+    }
+
+    /**
+     * Obtains local tracks for given {@link MediaType}.
+     * @param {MediaType} mediaType - audio or video.
+     * @return {Array<JitsiLocalTrack>} - array containing the local tracks
+     * attached to the peerconnection of the given media type.
+     */
+    _getLocalTracks(mediaType) {
+        const tracks = Array.from(this.pc.localTracks.values());
+
+        return tracks.filter(track => track.getType() === mediaType);
+    }
+
+    /**
+     * Obtains stream encodings that need to be configured on the given track.
+     * @param {JitsiLocalTrack} localTrack
+     */
+    _getStreamEncodings(localTrack) {
+        if (this.pc.isSimulcastOn() && localTrack.isVideoTrack()) {
+            return this.simulcastEncodings;
+        }
+
+        return [ { active: true } ];
+    }
+
+    /**
+     * Takes in a *unified plan* offer and inserts the appropriate
+     * parameters for adding simulcast receive support.
+     * @param {Object} desc - A session description object
+     * @param {String} desc.type - the type (offer/answer)
+     * @param {String} desc.sdp - the sdp content
+     *
+     * @return {Object} A session description (same format as above) object
+     * with its sdp field modified to advertise simulcast receive support
+     */
+    _insertUnifiedPlanSimulcastReceive(desc) {
+        // a=simulcast line is not needed on browsers where
+        // we munge SDP for turning on simulcast. Remove this check
+        // when we move to RID/MID based simulcast on all browsers.
+        if (browser.usesSdpMungingForSimulcast()) {
+            return desc;
+        }
+        const sdp = transform.parse(desc.sdp);
+        const idx = sdp.media.findIndex(mline => mline.type === 'video');
+
+        if (sdp.media[idx].rids && (sdp.media[idx].simulcast_03 || sdp.media[idx].simulcast)) {
+            // Make sure we don't have the simulcast recv line on video descriptions other than the
+            // the first video description.
+            sdp.media.forEach((mline, i) => {
+                if (mline.type === 'video' && i !== idx) {
+                    sdp.media[i].rids = undefined;
+                    sdp.media[i].simulcast = undefined;
+                }
+            });
+        }
+
+        // In order of highest to lowest spatial quality
+        sdp.media[idx].rids = [
+            {
+                id: SIM_LAYER_1_RID,
+                direction: 'recv'
+            },
+            {
+                id: SIM_LAYER_2_RID,
+                direction: 'recv'
+            },
+            {
+                id: SIM_LAYER_3_RID,
+                direction: 'recv'
+            }
+        ];
+
+        // Firefox 72 has stopped parsing the legacy rid= parameters in simulcast attributes.
+        // eslint-disable-next-line max-len
+        // https://www.fxsitecompat.dev/en-CA/docs/2019/pt-and-rid-in-webrtc-simulcast-attributes-are-no-longer-supported/
+        const simulcastLine = browser.isFirefox() && browser.isVersionGreaterThan(71)
+            ? `recv ${SIM_LAYER_RIDS.join(';')}`
+            : `recv rid=${SIM_LAYER_RIDS.join(';')}`;
+
+        // eslint-disable-next-line camelcase
+        sdp.media[idx].simulcast_03 = {
+            value: simulcastLine
+        };
+
+        return new RTCSessionDescription({
+            type: desc.type,
+            sdp: transform.write(sdp)
+        });
+    }
+
+    /**
+    * Adds {@link JitsiLocalTrack} to the WebRTC peerconnection for the first time.
+    * @param {JitsiLocalTrack} track - track to be added to the peerconnection.
+    * @returns {boolean} Returns true if the operation is successful,
+    * false otherwise.
+    */
+    addTrack(localTrack, isInitiator = true) {
+        const track = localTrack.getTrack();
+
+        if (isInitiator) {
+            // Use pc.addTransceiver() for the initiator case when local tracks are getting added
+            // to the peerconnection before a session-initiate is sent over to the peer.
+            const transceiverInit = {
+                direction: 'sendrecv',
+                streams: [ localTrack.getOriginalStream() ],
+                sendEncodings: []
+            };
+
+            if (!browser.isFirefox()) {
+                transceiverInit.sendEncodings = this._getStreamEncodings(localTrack);
+            }
+            this.pc.peerconnection.addTransceiver(track, transceiverInit);
+        } else {
+            // Use pc.addTrack() for responder case so that we can re-use the m-lines that were created
+            // when setRemoteDescription was called. pc.addTrack() automatically  attaches to any existing
+            // unused "recv-only" transceiver.
+            this.pc.peerconnection.addTrack(track);
+        }
+    }
+
+    /**
+     * Adds a track on the RTCRtpSender as part of the unmute operation.
+     * @param {JitsiLocalTrack} localTrack - track to be unmuted.
+     * @returns {boolean} Returns true if the operation is successful,
+     * false otherwise.
+     */
+    addTrackUnmute(localTrack) {
+        const mediaType = localTrack.getType();
+        const track = localTrack.getTrack();
+
+        // The assumption here is that the first transceiver of the specified
+        // media type is that of the local track.
+        const transceiver = this.pc.peerconnection.getTransceivers()
+            .find(t => t.receiver && t.receiver.track && t.receiver.track.kind === mediaType);
+
+        if (!transceiver) {
+            logger.error(`RTCRtpTransceiver for ${mediaType} on ${this.pc} not found`);
+
+            return false;
+        }
+        logger.info(`Adding ${localTrack} on ${this.pc}`);
+
+        // If the client starts with audio/video muted setting, the transceiver direction
+        // will be set to 'recvonly'. Use addStream here so that a MSID is generated for the stream.
+        if (transceiver.direction === 'recvonly') {
+            this.pc.peerconnection.addStream(localTrack.getOriginalStream());
+            this.setEncodings(localTrack);
+            this.pc.localTracks.set(localTrack.rtcId, localTrack);
+            transceiver.direction = 'sendrecv';
+
+            return true;
+        }
+        transceiver.sender.replaceTrack(track)
+            .then(() => {
+                this.pc.localTracks.set(localTrack.rtcId, localTrack);
+
+                return true;
+            })
+            .catch(err => {
+                logger.error(`Unmute track failed for ${mediaType} track on ${this.pc}, ${err}`);
+
+                return false;
+            });
+    }
+
+    /**
+     * Removes the track from the RTCRtpSender as part of the mute operation.
+     * @param {JitsiLocalTrack} localTrack - track to be removed.
+     * @returns {boolean} Returns true if the operation is successful,
+     * false otherwise.
+     */
+    removeTrackMute(localTrack) {
+        const mediaType = localTrack.getType();
+        const transceiver = this.pc.peerconnection.getTransceivers()
+            .find(t => t.sender && t.sender.track && t.sender.track.id === localTrack.getTrackId());
+
+        if (!transceiver) {
+            logger.error(`RTCRtpTransceiver for ${mediaType} on ${this.pc} not found`);
+
+            return false;
+        }
+
+        logger.info(`Removing ${localTrack} on ${this.pc}`);
+        transceiver.sender.replaceTrack(null)
+            .then(() => {
+                this.pc.localTracks.delete(localTrack.rtcId);
+                this.pc.localSSRCs.delete(localTrack.rtcId);
+
+                return true;
+            })
+            .catch(err => {
+                logger.error(`Mute track failed for ${mediaType} track on ${this.pc}, ${err}`);
+
+                return false;
+            });
+    }
+
+    /**
+     * Replaces the existing track on a RTCRtpSender with the given track.
+     * @param {JitsiLocalTrack} oldTrack - existing track on the sender that needs to be removed.
+     * @param {JitsiLocalTrack} newTrack - new track that needs to be added to the sender.
+     * @returns {Promise<false>} Promise that resolves with false as we don't want
+     * renegotiation to be triggered automatically after this operation. Renegotiation is
+     * done when the browser fires the negotiationeeded event.
+     */
+    replaceTrack(oldTrack, newTrack) {
+        if (oldTrack && newTrack) {
+            const mediaType = newTrack.getType();
+            const stream = newTrack.getOriginalStream();
+            const track = stream.getVideoTracks()[0];
+            const transceiver = this.pc.peerconnection.getTransceivers()
+                .find(t => t.receiver.track.kind === mediaType && !t.stopped);
+
+            if (!transceiver) {
+                return Promise.reject(new Error('replace track failed'));
+            }
+
+            return transceiver.sender.replaceTrack(track)
+                .then(() => {
+                    const ssrc = this.pc.localSSRCs.get(oldTrack.rtcId);
+
+                    this.pc.localTracks.delete(oldTrack.rtcId);
+                    this.pc.localSSRCs.delete(oldTrack.rtcId);
+                    this.pc._addedStreams = this.pc._addedStreams.filter(s => s !== stream);
+                    this.pc.localTracks.set(newTrack.rtcId, newTrack);
+
+                    this.pc._addedStreams.push(stream);
+                    this.pc.localSSRCs.set(newTrack.rtcId, ssrc);
+                    this.pc.eventEmitter.emit(RTCEvents.LOCAL_TRACK_SSRC_UPDATED,
+                        newTrack,
+                        this.pc._extractPrimarySSRC(ssrc));
+                });
+        } else if (oldTrack && !newTrack) {
+            if (!this.removeTrackMute(oldTrack)) {
+                return Promise.reject(new Error('replace track failed'));
+            }
+            this.pc.localTracks.delete(oldTrack.rtcId);
+            this.pc.localSSRCs.delete(oldTrack.rtcId);
+        } else if (newTrack && !oldTrack) {
+            const ssrc = this.pc.localSSRCs.get(newTrack.rtcId);
+
+            if (!this.addTrackUnmute(newTrack)) {
+                return Promise.reject(new Error('replace track failed'));
+            }
+            newTrack.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, newTrack);
+            this.pc.localTracks.set(newTrack.rtcId, newTrack);
+            this.pc.localSSRCs.set(newTrack.rtcId, ssrc);
+        }
+
+        return Promise.resolve(false);
+    }
+
+    /**
+     *
+     * @param {boolean} active
+     */
+    setAudioTransferActive(active) {
+        return this.setMediaTransferActive('audio', active);
+    }
+
+    /**
+     * Set the simulcast stream encoding properties on the RTCRtpSender.
+     * @param {*} track - the current track in use for which the encodings are to be set.
+     */
+    setEncodings(track) {
+        const transceiver = this.pc.peerconnection.getTransceivers()
+            .find(t => t.sender && t.sender.track && t.sender.track.kind === track.getType());
+        const parameters = transceiver.sender.getParameters();
+
+        parameters.encodings = this._getStreamEncodings(track);
+        transceiver.sender.setParameters(parameters);
+    }
+
+    /**
+     *
+     * @param {*} mediaType
+     * @param {boolean} active
+     */
+    setMediaTransferActive(mediaType, active) {
+        const transceivers = this.pc.peerconnection.getTransceivers()
+            .filter(t => t.receiver && t.receiver.track && t.receiver.track.kind === mediaType);
+
+        if (active) {
+            transceivers.forEach(transceiver => {
+                if (this._getLocalTracks(mediaType).length > 0) {
+                    transceiver.direction = 'sendrecv';
+                    const parameters = transceiver.sender.getParameters();
+
+                    if (parameters && parameters.encodings && parameters.encodings.length) {
+                        parameters.encodings.forEach(encoding => {
+                            encoding.active = true;
+                        });
+                        transceiver.sender.setParameters(parameters);
+                    }
+                } else {
+                    transceiver.direction = 'recvonly';
+                }
+            });
+        } else {
+            transceivers.forEach(transceiver => {
+                transceiver.direction = 'inactive';
+            });
+        }
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {boolean} active
+     */
+    setVideoTransferActive(active) {
+        return this.setMediaTransferActive('video', active);
+    }
+}

modules/RTC/TraceablePeerConnection.js

 
 import * as GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import JitsiRemoteTrack from './JitsiRemoteTrack';
-import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import * as MediaType from '../../service/RTC/MediaType';
 import LocalSdpMunger from './LocalSdpMunger';
 import RTC from './RTC';
 import browser from '../browser';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import RtxModifier from '../xmpp/RtxModifier';
+import { SIM_LAYER_RIDS, TPCUtils } from './TPCUtils';
 
 // FIXME SDP tools should end up in some kind of util module
 import SDP from '../xmpp/SDP';
 import * as SignalingEvents from '../../service/RTC/SignalingEvents';
 
 const logger = getLogger(__filename);
-const SIMULCAST_LAYERS = 3;
-const SIM_LAYER_1_RID = '1';
-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 MAX_BITRATE = 2500000;
 const DESKSTOP_SHARE_RATE = 500000;
 
 /* eslint-disable max-params */
 
     this.peerconnection
         = new RTCUtils.RTCPeerConnectionType(iceConfig, constraints);
+    this.tpcUtils = new TPCUtils(this);
     this.updateLog = [];
     this.stats = {};
     this.statsinterval = null;
     this.interop = new Interop();
     const Simulcast = require('@jitsi/sdp-simulcast');
 
-    this.simulcast = new Simulcast({ numOfLayers: SIMULCAST_LAYERS,
-        explodeRemoteSimulcast: false });
+    this.simulcast = new Simulcast(
+        {
+            numOfLayers: SIM_LAYER_RIDS.length,
+            explodeRemoteSimulcast: false,
+            usesUnifiedPlan: browser.usesUnifiedPlan()
+        });
     this.sdpConsistency = new SdpConsistency(this.toString());
 
     /**
         const sdp = transform.parse(desc.sdp);
         const video = sdp.media.find(mline => mline.type === 'video');
 
-        if (video.simulcast_03) {
+        if (video.simulcast) {
             const ssrcs = [];
 
             video.ssrcs.forEach(ssrc => {
  * Add {@link JitsiLocalTrack} to this TPC.
  * @param {JitsiLocalTrack} track
  */
-TraceablePeerConnection.prototype.addTrack = function(track) {
+TraceablePeerConnection.prototype.addTrack = function(track, isInitiator = false) {
     const rtcId = track.rtcId;
 
     logger.info(`add ${track} to: ${this}`);
     }
 
     this.localTracks.set(rtcId, track);
+    if (browser.usesUnifiedPlan() && isInitiator) {
+        return this.tpcUtils.addTrack(track, isInitiator);
+    }
 
     const webrtcStream = track.getOriginalStream();
 
             this.rtxModifier.setSsrcCache(rtxSsrcMapping);
         }
     }
+    if (browser.usesUnifiedPlan() && !browser.usesSdpMungingForSimulcast()) {
+        this.tpcUtils.setEncodings(track);
+    }
 };
 
 /**
     }
 
     logger.info(`Adding ${track} as unmute to ${this}`);
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.addTrackUnmute(track);
+    }
     const webRtcStream = track.getOriginalStream();
 
     if (!webRtcStream) {
  *       The same applies to addTrack.
  */
 TraceablePeerConnection.prototype.removeTrack = function(localTrack) {
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.removeTrack(localTrack);
+    }
     const webRtcStream = localTrack.getOriginalStream();
 
     this.trace(
  * renegotiation will be needed. Otherwise no renegotiation is needed.
  */
 TraceablePeerConnection.prototype.replaceTrack = function(oldTrack, newTrack) {
-    if (browser.supportsRtpSender() && oldTrack && newTrack) {
-        // Add and than remove stream in FF leads to wrong local SDP. In order
-        // to workaround the issue we need to use sender.replaceTrack().
-        const sender = this.findSenderByStream(oldTrack.getOriginalStream());
-        const stream = newTrack.getOriginalStream();
-
-        if (sender && stream) {
-            const track = stream.getTracks()[0];
-
-            if (track) {
-                return sender.replaceTrack(track, stream).then(() => {
-                    // Since there is no need to do renegotiations we need to
-                    // fix all ssrc-msid mappings here.
-                    // NOTE: after sender.replaceTrack the sdp will remain the
-                    // same but the stream attach to the new JitsiLocalTrack
-                    // will have different msid. Luckily on FF we are not doing
-                    // all the transformations related to video mute.
-
-                    const ssrc = this.localSSRCs.get(oldTrack.rtcId);
-
-                    this.localTracks.delete(oldTrack.rtcId);
-                    this.localSSRCs.delete(oldTrack.rtcId);
-                    this._addedStreams
-                        = this._addedStreams.filter(s => s !== stream);
-
-                    this.localTracks.set(newTrack.rtcId, newTrack);
-
-                    // Override the msid of JitsiLocalTrack in order to be
-                    // consistent with the SDP values.
-                    newTrack.storedMSID = oldTrack.storedMSID;
-                    this._addedStreams.push(stream);
-
-                    this.localSSRCs.set(newTrack.rtcId, ssrc);
-                    this.eventEmitter.emit(
-                        RTCEvents.LOCAL_TRACK_SSRC_UPDATED,
-                        newTrack,
-                        extractPrimarySSRC(ssrc));
-
-                    return false;
-                });
-            }
-        }
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.replaceTrack(oldTrack, newTrack);
     }
-
     if (oldTrack) {
         this.removeTrack(oldTrack);
     }
     return Promise.resolve(true);
 };
 
-/**
- * Replaces the existing media stream from the underlying peerconnection with the new
- * mediastream that has been added to the JitsiLocalTrack. Renegotiation with the remote
- * peer is not needed in this case.
- * @param {JitsiLocalTrack} localTrack - the localtrack whose mediastream has been updated.
- * @return {Promise} - Promise resolved with undefined if the track is replaced,
- * or rejected with <tt>InvalidModificationError<tt> if the track cannot be replaced.
- */
-TraceablePeerConnection.prototype.replaceTrackWithoutOfferAnswer = function(localTrack) {
-    const newTrack = localTrack.stream.getTracks()[0];
-    const sender = this.findSenderByKind(newTrack.kind);
-
-    if (!sender) {
-        return Promise.reject(new Error(`Could not find RTCRtpSender for ${newTrack.kind}`));
-    }
-
-    return sender.replaceTrack(newTrack)
-        .then(() => {
-            this._addedStreams = this._addedStreams.filter(s => s !== localTrack._originalStream);
-            this._addedStreams.push(localTrack.stream);
-            localTrack.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, localTrack);
-        })
-        .catch(err => {
-            logger.error(`replaceTrackWithoutOfferAnswer - replaceTrack failed for ${newTrack.kind}`, err);
-        });
-};
-
 /**
  * Removes local track as part of the mute operation.
  * @param {JitsiLocalTrack} localTrack the local track to be remove as part of
         // Abort - nothing to be done here
         return false;
     }
-
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.removeTrackMute(localTrack);
+    }
     if (webRtcStream) {
         logger.info(
             `Removing ${localTrack} as mute from ${this}`);
  */
 TraceablePeerConnection.prototype.setAudioTransferActive = function(active) {
     logger.debug(`${this} audio transfer active: ${active}`);
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.setAudioTransferActive(active);
+    }
     const changed = this.audioTransferActive !== active;
 
     this.audioTransferActive = active;
     return changed;
 };
 
-/**
- * Takes in a *unified plan* offer and inserts the appropriate
- * parameters for adding simulcast receive support.
- * @param {Object} desc - A session description object
- * @param {String} desc.type - the type (offer/answer)
- * @param {String} desc.sdp - the sdp content
- *
- * @return {Object} A session description (same format as above) object
- * with its sdp field modified to advertise simulcast receive support
- */
-TraceablePeerConnection.prototype._insertUnifiedPlanSimulcastReceive
-    = function(desc) {
-        const sdp = transform.parse(desc.sdp);
-        const video = sdp.media.find(mline => mline.type === 'video');
-
-        // In order of lowest to highest spatial quality
-        video.rids = [
-            {
-                id: SIM_LAYER_1_RID,
-                direction: 'recv'
-            },
-            {
-                id: SIM_LAYER_2_RID,
-                direction: 'recv'
-            },
-            {
-                id: SIM_LAYER_3_RID,
-                direction: 'recv'
-            }
-        ];
-        // eslint-disable-next-line camelcase
-        video.simulcast_03 = {
-            value: `recv rid=${SIM_LAYER_RIDS.join(';')}`
-        };
-
-        return new RTCSessionDescription({
-            type: desc.type,
-            sdp: transform.write(sdp)
-        });
-    };
-
 /**
  * Sets the max bitrate on the RTCRtpSender so that the
  * bitrate of the enocder doesn't exceed the configured value.
 TraceablePeerConnection.prototype.setMaxBitRate = function(localTrack) {
     const mediaType = localTrack.type;
 
-    if (!this.options.capScreenshareBitrate
-        || mediaType === MediaType.AUDIO) {
-
+    // No need to set max bitrates on the streams in the following cases.
+    // 1. When an audio track has been replaced.
+    // 2. When a 'camera' track is replaced in plan-b mode, since its a new sender.
+    // 3. When the config.js option for capping the SS bitrate is not enabled.
+    if ((mediaType === MediaType.AUDIO)
+        || (browser.usesPlanB() && !this.options.capScreenshareBitrate)
+        || (browser.usesPlanB() && localTrack.videoType === 'camera')) {
         return;
     }
     if (!this.peerconnection.getSenders) {
             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];
-                        }
+                if (!parameters.encodings || !parameters.encodings.length) {
+                    return;
+                }
+                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' && browser.usesPlanB()
+                                ? DESKSTOP_SHARE_RATE
+
+                                // In unified plan, simulcast for SS is on by default.
+                                // When simulcast is disabled through a config.js option,
+                                // we cap the bitrate on desktop and camera tracks to 2500 Kbps.
+                                : this.isSimulcastOn()
+                                    ? this.tpcUtils.simulcastEncodings[encoding].maxBitrate
+                                    : MAX_BITRATE;
                     }
-                    sender.setParameters(parameters);
                 }
+                sender.setParameters(parameters);
             } catch (err) {
                 logger.error('Browser does not support getParameters/setParamters '
                     + 'or setting max bitrate on the encodings: ', err);
 
         if (this.isSimulcastOn()) {
             // eslint-disable-next-line no-param-reassign
-            description = this._insertUnifiedPlanSimulcastReceive(description);
+            description = this.tpcUtils._insertUnifiedPlanSimulcastReceive(description);
             this.trace(
                 'setRemoteDescription::postTransform (sim receive)',
                 dumpSDP(description));
  */
 TraceablePeerConnection.prototype.setVideoTransferActive = function(active) {
     logger.debug(`${this} video transfer active: ${active}`);
+    if (browser.usesUnifiedPlan()) {
+        return this.tpcUtils.setVideoTransferActive(active);
+    }
     const changed = this.videoTransferActive !== active;
 
     this.videoTransferActive = active;
             = this.peerconnection.getSenders().find(sender =>
                 sender.track !== null && sender.track.kind === 'video');
         const simParams = {
-            encodings: [
-                {
-                    rid: SIM_LAYER_1_RID,
-                    scaleResolutionDownBy: 4
-                },
-                {
-                    rid: SIM_LAYER_2_RID,
-                    scaleResolutionDownBy: 2
-                },
-                {
-                    rid: SIM_LAYER_3_RID
-                }
-            ]
+            encodings: this.tpcUtils.simulcastEncodings
         };
 
         videoSender.setParameters(simParams);
             // 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()
+            if (this.isSimulcastOn() && browser.usesSdpMungingForSimulcast()
                 && (!this.options.capScreenshareBitrate
                 || (this.options.capScreenshareBitrate && hasCameraTrack(this)))) {
                 // eslint-disable-next-line no-param-reassign
  * @param {TrackSSRCInfo} ssrcObj
  * @return {number|null} the primary SSRC or <tt>null</tt>
  */
-function extractPrimarySSRC(ssrcObj) {
+TraceablePeerConnection.prototype._extractPrimarySSRC = function(ssrcObj) {
     if (ssrcObj && ssrcObj.groups && ssrcObj.groups.length) {
         return ssrcObj.groups[0].ssrcs[0];
     } else if (ssrcObj && ssrcObj.ssrcs && ssrcObj.ssrcs.length) {
     }
 
     return null;
-}
+};
 
 /**
  * Goes over the SSRC map extracted from the latest local description and tries
                 return;
             }
             const oldSSRC = this.localSSRCs.get(track.rtcId);
-            const newSSRCNum = extractPrimarySSRC(newSSRC);
-            const oldSSRCNum = extractPrimarySSRC(oldSSRC);
+            const newSSRCNum = this._extractPrimarySSRC(newSSRC);
+            const oldSSRCNum = this._extractPrimarySSRC(oldSSRC);
 
             // eslint-disable-next-line no-negated-condition
             if (newSSRCNum !== oldSSRCNum) {
             ssrcs: [],
             groups: []
         };
-        for (let i = 0; i < SIMULCAST_LAYERS; i++) {
+        for (let i = 0; i < SIM_LAYER_RIDS.length; i++) {
             ssrcInfo.ssrcs.push(SDPUtil.generateSsrc());
         }
         ssrcInfo.groups.push({

modules/xmpp/JingleSessionPC.js

 import { $iq, Strophe } from 'strophe.js';
 import { integerHash } from '../util/StringUtils';
 
+import browser from './../browser';
 import JingleSession from './JingleSession';
 import * as JingleSessionState from './JingleSessionState';
 import SDP from './SDP';
                 break;
             }
         };
+
+        /**
+         * The negotiationneeded event is fired whenever we shake the media on the
+         * RTCPeerConnection object.
+         */
         this.peerconnection.onnegotiationneeded = () => {
+            const state = this.peerconnection.signalingState;
+            const remoteDescription = this.peerconnection.remoteDescription;
+
             this.room.eventEmitter.emit(XMPPEvents.PEERCONNECTION_READY, this);
+            if (browser.usesUnifiedPlan() && state.toString() === 'stable'
+                && remoteDescription && typeof remoteDescription.sdp === 'string') {
+                logger.debug(`onnegotiationneeded fired on ${this.peerconnection} in state: ${state}`);
+                const workFunction = finishedCallback => {
+                    const oldSdp = new SDP(this.peerconnection.localDescription.sdp);
+
+                    this._renegotiate()
+                        .then(() => {
+                            const newSdp = new SDP(this.peerconnection.localDescription.sdp);
+
+                            this.notifyMySSRCUpdate(oldSdp, newSdp);
+                            finishedCallback();
+                        })
+                        .catch(() => {
+                            finishedCallback();
+                        });
+                };
+
+                this.modificationQueue.push(
+                    workFunction,
+                    error => {
+                        if (error) {
+                            logger.error('onnegotiationneeded error', error);
+                        } else {
+                            logger.debug('onnegotiationneeded executed - OK');
+                        }
+                    });
+            }
         };
 
         // The signaling layer will bind it's listeners at this point
         }
         const workFunction = finishedCallback => {
             for (const localTrack of localTracks) {
-                this.peerconnection.addTrack(localTrack);
+                this.peerconnection.addTrack(localTrack, true /* isInitiator */);
             }
             this.peerconnection.createOffer(this.mediaConstraints)
                 .then(offerSdp => {
             });
     }
 
-    /**
-     * Replaces the existing mediaStream on the underlying peerconnection with the newly
-     * added stream on the same JitsiLocalTrack wihtout the need to perform a offer/answer
-     * cycle.
-     * @param {JitsiLocalTrack} track - the current track in use whose media stream has been
-     * updated.
-     * @returns {Promise} which resolves once the replacement is complete or reject with an
-     * error {string}.
-     */
-    replaceTrackWithoutOfferAnswer(track) {
-        return this.peerconnection.replaceTrackWithoutOfferAnswer(track);
-    }
-
     /**
      * Replaces <tt>oldTrack</tt> with <tt>newTrack</tt> and performs a single
      * offer/answer cycle after both operations are done. Either
         const workFunction = finishedCallback => {
             const oldLocalSdp = this.peerconnection.localDescription.sdp;
 
-            // NOTE the code below assumes that no more than 1 video track
-            // can be added to the peer connection.
-            // 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();
-            }
+            if (browser.usesPlanB()) {
+                // NOTE the code below assumes that no more than 1 video track
+                // can be added to the peer connection.
+                // 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
-                // with:
-                // 1. source-remove for the recvonly
-                // 2. source-add for the new video stream
-                this.peerconnection.clearRecvonlySsrc();
-
-            // Transition from video to no video
-            } else if (oldTrack && oldTrack.isVideoTrack() && !newTrack) {
-                // Clearing current primary SSRC and generating the recvonly
-                // will result in:
-                // 1. source-remove for the old video stream
-                // 2. source-add for the recvonly stream
-                this.peerconnection.clearRecvonlySsrc();
-                this.peerconnection.generateRecvonlySsrc();
+                // 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
+                    // with:
+                    // 1. source-remove for the recvonly
+                    // 2. source-add for the new video stream
+                    this.peerconnection.clearRecvonlySsrc();
+
+                // Transition from video to no video
+                } else if (oldTrack && oldTrack.isVideoTrack() && !newTrack) {
+                    // Clearing current primary SSRC and generating the recvonly
+                    // will result in:
+                    // 1. source-remove for the old video stream
+                    // 2. source-add for the recvonly stream
+                    this.peerconnection.clearRecvonlySsrc();
+                    this.peerconnection.generateRecvonlySsrc();
+                }
             }
 
             this.peerconnection.replaceTrack(oldTrack, newTrack)
-            .then(shouldRenegotiate => {
-                if (shouldRenegotiate
-                    && (oldTrack || newTrack)
-                    && this.state === JingleSessionState.ACTIVE) {
-                    this._renegotiate()
-                        .then(() => {
-                            const newLocalSDP
-                                = new SDP(
-                                    this.peerconnection.localDescription.sdp);
-
-                            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();
+                .then(shouldRenegotiate => {
+                    let promise = Promise.resolve();
+
+                    if (shouldRenegotiate
+                        && (oldTrack || newTrack)
+                        && this.state === JingleSessionState.ACTIVE) {
+                        promise = this._renegotiate().then(() => {
+                            const newLocalSDP = new SDP(this.peerconnection.localDescription.sdp);
+
+                            this.notifyMySSRCUpdate(new SDP(oldLocalSdp), newLocalSDP);
                         },
                         finishedCallback /* will be called with en error */);
-                } else {
-                    finishedCallback();
-                }
-            });
+                    }
+
+                    // Wait for the renegotation to be done if needed (plan-b) before adjusting
+                    // the max bitrates on the video sender.
+                    promise.then(() => {
+                        // 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 */);
+                })
+                .catch(err => {
+                    finishedCallback(err);
+                });
         };
 
         return new Promise((resolve, reject) => {
 
             if (!tpcOperation()) {
                 finishedCallback(`${operationName} failed!`);
-            } else if (!oldLocalSDP || !tpc.remoteDescription.sdp) {
+
+            // Do not renegotiate when browser is running in Unified-plan mode.
+            } else if (!oldLocalSDP || !tpc.remoteDescription.sdp || browser.usesUnifiedPlan()) {
                 finishedCallback();
             } else {
                 this._renegotiate()