fix(RTC): Remove support for plan-b SDP. (#2430)

* fix(RTC): Remove support for plan-b SDP.
Since unified plan mode becomes the default mode, so does multi-stream mode.

* squash: Remove plan-b unit tests and fix comments

* squash: address review comments

JitsiConference.js

 
         // Currently, only adding multiple video streams of different video types is supported.
         // TODO - remove this limitation once issues with jitsi-meet trying to add multiple camera streams is fixed.
-        if (FeatureFlags.isMultiStreamSendSupportEnabled()
-            && mediaType === MediaType.VIDEO
+        if (mediaType === MediaType.VIDEO
             && !localTracks.find(t => t.getVideoType() === track.getVideoType())) {
             const sourceName = getSourceNameForJitsiTrack(
                 this.myUserId(),
             // Presence needs to be sent here for desktop track since we need the presence to reach the remote peer
             // before signaling so that a fake participant tile is created for screenshare. Otherwise, presence will
             // only be sent after a session-accept or source-add is ack'ed.
-            if (track.getVideoType() === VideoType.DESKTOP && FeatureFlags.isMultiStreamSendSupportEnabled()) {
+            if (track.getVideoType() === VideoType.DESKTOP) {
                 this._updateRoomPresence(this.getActiveMediaSession());
             }
         });
     const mediaType = oldTrack?.getType() || newTrack?.getType();
     const newVideoType = newTrack?.getVideoType();
 
-    if (FeatureFlags.isMultiStreamSendSupportEnabled() && oldTrack && newTrack && oldVideoType !== newVideoType) {
+    if (oldTrack && newTrack && oldVideoType !== newVideoType) {
         throw new Error(`Replacing a track of videoType=${oldVideoType} with a track of videoType=${newVideoType} is`
             + ' not supported in this mode.');
     }
  */
 JitsiConference.prototype._onIncomingCallP2P = function(jingleSession, jingleOffer) {
     let rejectReason;
-    const usesUnifiedPlan = browser.supportsUnifiedPlan();
     const contentName = jingleOffer.find('>content').attr('name');
     const peerUsesUnifiedPlan = contentName === '0' || contentName === '1';
 
     // Reject P2P between endpoints that are not running in the same mode w.r.t to SDPs (plan-b and unified plan).
-    if (usesUnifiedPlan !== peerUsesUnifiedPlan) {
+    if (!peerUsesUnifiedPlan) {
         rejectReason = {
             reason: 'decline',
             reasonDescription: 'P2P disabled',
             localTracks
         );
 
-        // Enable or disable simulcast for plan-b screensharing based on the capture fps if it is set through the UI.
+        // Set the capture fps for screenshare if it is set through the UI.
         this._desktopSharingFrameRate
             && jingleSession.peerconnection.setDesktopSharingFrameRate(this._desktopSharingFrameRate);
 
 
     this._desktopSharingFrameRate = maxFps;
 
-    // Enable or disable simulcast for plan-b screensharing based on the capture fps.
+    // Set capture fps for screenshare.
     this.jvbJingleSession && this.jvbJingleSession.peerconnection.setDesktopSharingFrameRate(maxFps);
 
     // Set the capture rate for desktop sharing.

modules/RTC/JitsiLocalTrack.js

     createNoDataFromSourceEvent
 } from '../../service/statistics/AnalyticsEvents';
 import browser from '../browser';
-import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
 
 import JitsiTrack from './JitsiTrack';
      * @returns {Promise}
      */
     _setMuted(muted) {
-        if (this.isMuted() === muted
-            && !(this.videoType === VideoType.DESKTOP && FeatureFlags.isMultiStreamSendSupportEnabled())) {
+        if (this.isMuted() === muted && this.videoType !== VideoType.DESKTOP) {
             return Promise.resolve();
         }
 
         // conference. This is needed because we don't want the client to signal a source-remove to the remote peer for
         // the desktop track when screenshare is stopped. Later when screenshare is started again, the same sender will
         // be re-used without the need for signaling a new ssrc through source-add.
-        if (this.isAudioTrack()
-                || (this.videoType === VideoType.DESKTOP && !FeatureFlags.isMultiStreamSendSupportEnabled())
-                || !doesVideoMuteByStreamRemove) {
+        if (this.isAudioTrack() || !doesVideoMuteByStreamRemove) {
             logMuteInfo();
 
             // If we have a stream effect that implements its own mute functionality, prioritize it before

modules/RTC/RTC.js

      * enabled on the PeerConnection.
      * @param {boolean} options.forceTurnRelay If set to true, the browser will generate only Relay ICE candidates.
      * @param {boolean} options.startSilent If set to 'true' no audio will be sent or received.
-     * @param {boolean} options.usesUnifiedPlan Indicates if the  browser is running in unified plan mode.
      * @param {Object} options.videoQuality - Quality settings to applied on the outbound video streams.
      * @return {TraceablePeerConnection}
      */
             pcConfig.encodedInsertableStreams = true;
         }
 
-        // TODO: remove this.
-        const supportsSdpSemantics = browser.isChromiumBased() && !options.usesUnifiedPlan;
-
-        if (supportsSdpSemantics) {
-            logger.debug('WebRTC application is running in plan-b mode');
-            pcConfig.sdpSemantics = 'plan-b';
-        }
-
         if (options.forceTurnRelay) {
             pcConfig.iceTransportPolicy = 'relay';
         }

modules/RTC/TPCUtils.js

 import VideoEncoderScalabilityMode from '../../service/RTC/VideoEncoderScalabilityMode';
 import { VideoType } from '../../service/RTC/VideoType';
 import browser from '../browser';
-import FeatureFlags from '../flags/FeatureFlags';
 
 const logger = getLogger(__filename);
 const DESKTOP_SHARE_RATE = 500000;
      * @returns {Array<number>}
      */
     calculateEncodingsBitrates(localVideoTrack, codec, newHeight) {
-        const videoType = localVideoTrack.getVideoType();
         const desktopShareBitrate = this.pc.options?.videoQuality?.desktopbitrate || DESKTOP_SHARE_RATE;
         const encodingsBitrates = this._getVideoStreamEncodings(localVideoTrack.getVideoType(), codec)
         .map((encoding, idx) => {
             // Multiple video streams.
             if (this._isScreenshareBitrateCapped(localVideoTrack)) {
                 bitrate = desktopShareBitrate;
-            } else if (videoType === VideoType.DESKTOP && browser.isChromiumBased() && !this.pc.usesUnifiedPlan()) {
-                // For high fps screenshare, 'maxBitrate' setting must be cleared on Chrome in plan-b, because
-                // if simulcast is enabled for screen and maxBitrates are set then Chrome will not send the
-                // desktop stream.
-                bitrate = undefined;
             }
 
             return bitrate;
         const mediaType = newTrack?.getType() ?? oldTrack?.getType();
         const localTracks = this.pc.getLocalTracks(mediaType);
         const track = newTrack?.getTrack() ?? null;
-        const isNewLocalSource = FeatureFlags.isMultiStreamSendSupportEnabled()
-            && localTracks?.length
+        const isNewLocalSource = localTracks?.length
             && !oldTrack
             && newTrack
             && !localTracks.find(t => t === newTrack);

modules/browser/BrowserCapabilities.js

             && window.RTCRtpReceiver.getCapabilities('audio').codecs.some(codec => codec.mimeType === 'audio/red'));
     }
 
-    /**
-     * Checks if the browser supports unified plan.
-     *
-     * @returns {boolean}
-     */
-    supportsUnifiedPlan() {
-        // We do not want to enable unified plan on Electron clients that have Chromium version < 96 because of
-        // performance and screensharing issues.
-        return !(this.isElectron() && this.isEngineVersionLessThan(96));
-    }
-
     /**
      * Checks if the browser supports voice activity detection via the @type {VADAudioAnalyser} service.
      *

modules/flags/FeatureFlags.js

         this._joinAsVisitor = Boolean(flags.enableJoinAsVisitor ?? true);
     }
 
-    /**
-     * Checks if multiple local video streams support is enabled.
-     *
-     * @returns {boolean}
-     */
-    isMultiStreamSendSupportEnabled() {
-        return browser.supportsUnifiedPlan();
-    }
-
     /**
      * Checks if the run in lite mode is enabled.
      * This will cause any media to be received and not decoded. (Insertable streams are used to discard

modules/sdp/LocalSdpMunger.js

 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import { MediaType } from '../../service/RTC/MediaType';
 import { getSourceNameForJitsiTrack } from '../../service/RTC/SignalingLayer';
-import { VideoType } from '../../service/RTC/VideoType';
 import browser from '../browser';
-import FeatureFlags from '../flags/FeatureFlags';
 
 import { SdpTransformWrap } from './SdpTransformUtil';
 
         this.videoSourcesToMsidMap = new Map();
     }
 
-    /**
-     * Makes sure that muted local video tracks associated with the parent
-     * {@link TraceablePeerConnection} are described in the local SDP. It's done
-     * in order to prevent from sending 'source-remove'/'source-add' Jingle
-     * notifications when local video track is muted (<tt>MediaStream</tt> is
-     * removed from the peerconnection).
-     *
-     * NOTE 1 video track is assumed
-     *
-     * @param {SdpTransformWrap} transformer the transformer instance which will
-     * be used to process the SDP.
-     * @return {boolean} <tt>true</tt> if there were any modifications to
-     * the SDP wrapped by <tt>transformer</tt>.
-     * @private
-     */
-    _addMutedLocalVideoTracksToSDP(transformer) {
-        // Go over each video tracks and check if the SDP has to be changed
-        const localVideos = this.tpc.getLocalTracks(MediaType.VIDEO);
-
-        if (!localVideos.length) {
-            return false;
-        } else if (localVideos.length !== 1) {
-            logger.error(
-                `${this.tpc} there is more than 1 video track ! `
-                    + 'Strange things may happen !', localVideos);
-        }
-
-        const videoMLine = transformer.selectMedia(MediaType.VIDEO)?.[0];
-
-        if (!videoMLine) {
-            logger.debug(
-                `${this.tpc} unable to hack local video track SDP`
-                    + '- no "video" media');
-
-            return false;
-        }
-
-        let modified = false;
-
-        for (const videoTrack of localVideos) {
-            const muted = videoTrack.isMuted();
-            const mediaStream = videoTrack.getOriginalStream();
-            const isCamera = videoTrack.videoType === VideoType.CAMERA;
-
-            // During the mute/unmute operation there are periods of time when
-            // the track's underlying MediaStream is not added yet to
-            // the PeerConnection. The SDP needs to be munged in such case.
-            const isInPeerConnection
-                = mediaStream && this.tpc.isMediaStreamInPc(mediaStream);
-            const shouldFakeSdp = isCamera && (muted || !isInPeerConnection);
-
-            if (!shouldFakeSdp) {
-                continue; // eslint-disable-line no-continue
-            }
-
-            // Inject removed SSRCs
-            const requiredSSRCs
-                = this.tpc.isSpatialScalabilityOn()
-                    ? this.tpc.simulcast.ssrcCache
-                    : [ this.tpc.sdpConsistency.cachedPrimarySsrc ];
-
-            if (!requiredSSRCs.length) {
-                logger.error(`No SSRCs stored for: ${videoTrack} in ${this.tpc}`);
-
-                continue; // eslint-disable-line no-continue
-            }
-
-            modified = true;
-
-            // We need to fake sendrecv.
-            // NOTE the SDP produced here goes only to Jicofo and is never set
-            // as localDescription. That's why
-            // TraceablePeerConnection.mediaTransferActive is ignored here.
-            videoMLine.direction = MediaDirection.SENDRECV;
-
-            // Check if the recvonly has MSID
-            const primarySSRC = requiredSSRCs[0];
-
-            // FIXME The cname could come from the stream, but may turn out to
-            // be too complex. It is fine to come up with any value, as long as
-            // we only care about the actual SSRC values when deciding whether
-            // or not an update should be sent.
-            const primaryCname = `injected-${primarySSRC}`;
-
-            for (const ssrcNum of requiredSSRCs) {
-                // Remove old attributes
-                videoMLine.removeSSRC(ssrcNum);
-
-                // Inject
-                videoMLine.addSSRCAttribute({
-                    id: ssrcNum,
-                    attribute: 'cname',
-                    value: primaryCname
-                });
-                videoMLine.addSSRCAttribute({
-                    id: ssrcNum,
-                    attribute: 'msid',
-                    value: videoTrack.storedMSID
-                });
-            }
-            if (requiredSSRCs.length > 1) {
-                const group = {
-                    ssrcs: requiredSSRCs.join(' '),
-                    semantics: 'SIM'
-                };
-
-                if (!videoMLine.findGroup(group.semantics, group.ssrcs)) {
-                    // Inject the group
-                    videoMLine.addSSRCGroup(group);
-                }
-            }
-
-            // Insert RTX
-            // FIXME in P2P RTX is used by Chrome regardless of config option
-            // status. Because of that 'source-remove'/'source-add'
-            // notifications are still sent to remove/add RTX SSRC and FID group
-            if (!this.tpc.options.disableRtx) {
-                this.tpc.rtxModifier.modifyRtxSsrcs2(videoMLine);
-            }
-        }
-
-        return modified;
-    }
-
     /**
      * Returns a string that can be set as the MSID attribute for a source.
      *
         }
     }
 
-    /**
-     * Maybe modifies local description to fake local video tracks SDP when
-     * those are muted.
-     *
-     * @param {object} desc the WebRTC SDP object instance for the local
-     * description.
-     * @returns {RTCSessionDescription}
-     */
-    maybeAddMutedLocalVideoTracksToSDP(desc) {
-        if (!desc) {
-            throw new Error('No local description passed in.');
-        }
-
-        const transformer = new SdpTransformWrap(desc.sdp);
-
-        if (this._addMutedLocalVideoTracksToSDP(transformer)) {
-            return new RTCSessionDescription({
-                type: desc.type,
-                sdp: transformer.toRawSDP()
-            });
-        }
-
-        return desc;
-    }
-
     /**
      * This transformation will make sure that stream identifiers are unique
      * across all of the local PeerConnections even if the same stream is used
 
         const videoMlines = transformer.selectMedia(MediaType.VIDEO);
 
-        if (!FeatureFlags.isMultiStreamSendSupportEnabled()) {
-            videoMlines.splice(1);
-        }
-
         for (const videoMLine of videoMlines) {
             this._transformMediaIdentifiers(videoMLine);
             this._injectSourceNames(videoMLine);
         }
 
-        // Plan-b clients generate new SSRCs and trackIds whenever tracks are removed and added back to the
-        // peerconnection, therefore local track based map for msids needs to be reset after every transformation.
-        if (!this.tpc._usesUnifiedPlan) {
-            this.audioSourcesToMsidMap.clear();
-            this.videoSourcesToMsidMap.clear();
-        }
-
         return new RTCSessionDescription({
             type: sessionDesc.type,
             sdp: transformer.toRawSDP()

modules/sdp/LocalSdpMunger.spec.js

         expect(videoMsid).toBe('sRdpsdg-video-0-1');
     });
 });
-
-describe('Track replace operations in plan-b', () => {
-    const tpc = new MockPeerConnection('1', false);
-    const localEndpointId = 'sRdpsdg';
-    let desc, newSdp, sdpStr, transformedDesc, videoMsid, videoMsidLine;
-    const localSdpMunger = new LocalSdpMunger(tpc, localEndpointId);
-
-    it('should not increment track index for new tracks', () => {
-        FeatureFlags.init({ });
-
-        sdpStr = transform.write(SampleSdpStrings.simulcastRtxSdp);
-        desc = new RTCSessionDescription({
-            type: 'offer',
-            sdp: sdpStr
-        });
-        transformedDesc = localSdpMunger.transformStreamIdentifiers(desc);
-        newSdp = transform.parse(transformedDesc.sdp);
-
-        videoMsidLine = getSsrcLines(newSdp, 'video').find(ssrc => ssrc.attribute === 'msid')?.value;
-        videoMsid = videoMsidLine.split(' ')[0];
-
-        expect(videoMsid).toBe('sRdpsdg-video-0-1');
-
-        sdpStr = transform.write(SampleSdpStrings.simulcastRtxSdpReplacedTrack);
-        desc = new RTCSessionDescription({
-            type: 'offer',
-            sdp: sdpStr
-        });
-        transformedDesc = localSdpMunger.transformStreamIdentifiers(desc);
-        newSdp = transform.parse(transformedDesc.sdp);
-
-        videoMsidLine = getSsrcLines(newSdp, 'video').find(ssrc => ssrc.attribute === 'msid')?.value;
-        videoMsid = videoMsidLine.split(' ')[0];
-
-        expect(videoMsid).toBe('sRdpsdg-video-0-1');
-    });
-});
-
-describe('Transform msids for plan-b', () => {
-    const tpc = new MockPeerConnection('1', false);
-    const localEndpointId = 'sRdpsdg';
-    let desc, newSdp, sdpStr, transformedDesc;
-    const localSdpMunger = new LocalSdpMunger(tpc, localEndpointId);
-
-    it('should inject source-names', () => {
-        sdpStr = transform.write(SampleSdpStrings.simulcastRtxSdp);
-        desc = new RTCSessionDescription({
-            type: 'offer',
-            sdp: sdpStr
-        });
-        transformedDesc = localSdpMunger.transformStreamIdentifiers(desc);
-        newSdp = transform.parse(transformedDesc.sdp);
-
-        const audioSsrcs = getSsrcLines(newSdp, 'audio');
-        const videoSsrcs = getSsrcLines(newSdp, 'video');
-
-        expect(audioSsrcs.length).toEqual(1 + 1 /* injected source name */);
-        expect(videoSsrcs.length).toEqual(6 + 6 /* injected source name into each ssrc */);
-    });
-});

modules/sdp/SdpConsistency.js

-import { getLogger } from '@jitsi/logger';
-
-import { MediaType } from '../../service/RTC/MediaType';
-
-import {
-    SdpTransformWrap,
-    parsePrimarySSRC,
-    parseSecondarySSRC
-} from './SdpTransformUtil';
-
-const logger = getLogger(__filename);
-
-/**
- * Handles the work of keeping video ssrcs consistent across multiple
- * o/a cycles, making it such that all stream operations can be
- * kept local and do not need to be signaled.
- * NOTE: This only keeps the 'primary' video ssrc consistent: meaning
- * the primary video stream
- */
-export default class SdpConsistency {
-    /**
-     * Constructor
-     * @param {string} logPrefix the log prefix appended to every logged
-     * message, currently used to distinguish for which
-     * <tt>TraceablePeerConnection</tt> the instance works.
-     */
-    constructor(logPrefix) {
-        this.clearVideoSsrcCache();
-        this.logPrefix = logPrefix;
-    }
-
-    /**
-     * Clear the cached video primary and primary rtx ssrcs so that
-     *  they will not be used for the next call to
-     *  makeVideoPrimarySsrcsConsistent
-     */
-    clearVideoSsrcCache() {
-        this.cachedPrimarySsrc = null;
-        this.injectRecvOnly = false;
-    }
-
-    /**
-     * Explicitly set the primary ssrc to be used in
-     *  makeVideoPrimarySsrcsConsistent
-     * @param {number} primarySsrc the primarySsrc to be used
-     *  in future calls to makeVideoPrimarySsrcsConsistent
-     * @throws Error if <tt>primarySsrc</tt> is not a number
-     */
-    setPrimarySsrc(primarySsrc) {
-        if (typeof primarySsrc !== 'number') {
-            throw new Error('Primary SSRC must be a number!');
-        }
-        this.cachedPrimarySsrc = primarySsrc;
-    }
-
-    /**
-     * Checks whether or not there is a primary video SSRC cached already.
-     * @return {boolean}
-     */
-    hasPrimarySsrcCached() {
-        return Boolean(this.cachedPrimarySsrc);
-    }
-
-    /**
-     * Given an sdp string, either:
-     *  1) record the primary video and primary rtx ssrcs to be
-     *   used in future calls to makeVideoPrimarySsrcsConsistent or
-     *  2) change the primary and primary rtx ssrcs in the given sdp
-     *   to match the ones previously cached
-     * @param {string} sdpStr the sdp string to (potentially)
-     *  change to make the video ssrcs consistent
-     * @returns {string} a (potentially) modified sdp string
-     *  with ssrcs consistent with this class' cache
-     */
-    makeVideoPrimarySsrcsConsistent(sdpStr) {
-        const sdpTransformer = new SdpTransformWrap(sdpStr);
-        const videoMLine = sdpTransformer.selectMedia(MediaType.VIDEO)?.[0];
-
-        if (!videoMLine) {
-            logger.debug(`${this.logPrefix} no 'video' media found in the sdp: ${sdpStr}`);
-
-            return sdpStr;
-        }
-
-        if (videoMLine.direction === 'recvonly') {
-            // If the mline is recvonly, we'll add the primary
-            //  ssrc as a recvonly ssrc
-            if (this.cachedPrimarySsrc && this.injectRecvOnly) {
-                videoMLine.addSSRCAttribute({
-                    id: this.cachedPrimarySsrc,
-                    attribute: 'cname',
-                    value: `recvonly-${this.cachedPrimarySsrc}`
-                });
-            } else {
-                logger.info(`${this.logPrefix} no SSRC found for the recvonly video stream!`);
-            }
-        } else {
-            const newPrimarySsrc = videoMLine.getPrimaryVideoSsrc();
-
-            if (!newPrimarySsrc) {
-                logger.info(`${this.logPrefix} sdp-consistency couldn't parse new primary ssrc`);
-
-                return sdpStr;
-            }
-            if (this.cachedPrimarySsrc) {
-                videoMLine.replaceSSRC(newPrimarySsrc, this.cachedPrimarySsrc);
-                for (const group of videoMLine.ssrcGroups) {
-                    if (group.semantics === 'FID') {
-                        const primarySsrc = parsePrimarySSRC(group);
-                        const rtxSsrc = parseSecondarySSRC(group);
-
-                        // eslint-disable-next-line max-depth
-                        if (primarySsrc === newPrimarySsrc) {
-                            group.ssrcs
-                                = `${this.cachedPrimarySsrc} ${rtxSsrc}`;
-                        }
-                    }
-                }
-            } else {
-                this.cachedPrimarySsrc = newPrimarySsrc;
-            }
-            this.injectRecvOnly = true;
-        }
-
-        return sdpTransformer.toRawSDP();
-    }
-}

modules/xmpp/JingleSessionPC.js

         }
         pcOptions.forceTurnRelay = options.forceTurnRelay;
         pcOptions.audioQuality = options.audioQuality;
-        pcOptions.usesUnifiedPlan = this.usesUnifiedPlan = browser.supportsUnifiedPlan();
         pcOptions.disableSimulcast = this.isP2P ? true : options.disableSimulcast;
 
         if (!this.isP2P) {
                 if (!this.wasConnected
                     && (this.wasstable
                         || isStable
-                        || (this.usesUnifiedPlan && this.isInitiator
-                            && (browser.isChromiumBased() || browser.isReactNative())))) {
+                        || (this.isInitiator && (browser.isChromiumBased() || browser.isReactNative())))) {
 
                     Statistics.sendAnalytics(
                         ICE_DURATION,
             const state = this.peerconnection.signalingState;
             const remoteDescription = this.peerconnection.remoteDescription;
 
-            if (this.usesUnifiedPlan
-                && !this.isP2P
+            if (!this.isP2P
                 && state === 'stable'
                 && remoteDescription
                 && typeof remoteDescription.sdp === 'string') {
         });
     }
 
-    /**
-     * Makes the underlying TraceablePeerConnection generate new SSRC for
-     * the recvonly video stream.
-     * @deprecated
-     */
-    generateRecvonlySsrc() {
-        if (this.peerconnection) {
-            this.peerconnection.generateRecvonlySsrc();
-        } else {
-            logger.error(`${this} Unable to generate recvonly SSRC - no peerconnection`);
-        }
-    }
-
     /**
      * Returns the video codec configured as the preferred codec on the peerconnection.
      */
                     const videoTracks = localTracks.filter(track => track.getType() === MediaType.VIDEO);
 
                     videoTracks.length && videoTracks.splice(0, 1);
-                    if (FeatureFlags.isMultiStreamSendSupportEnabled() && videoTracks.length) {
-                        this.addTracks(videoTracks);
-                    }
+                    videoTracks.length && this.addTracks(videoTracks);
                 },
                 error => {
                     failure(error);
         // Add only 1 video track at a time. Adding 2 or more video tracks to the peerconnection at the same time
         // makes the browser go into a renegotiation loop by firing 'negotiationneeded' event after every
         // renegotiation.
-        if (FeatureFlags.isMultiStreamSendSupportEnabled() && videoTracks.length > 1) {
+        if (videoTracks.length > 1) {
             tracks = [ ...audioTracks, videoTracks[0] ];
         }
         for (const track of tracks) {
                 if (currentRemoteSdp.containsSSRC(ssrc)) {
 
                     // Do not print the warning for unified plan p2p case since ssrcs are never removed from the SDP.
-                    !(self.usesUnifiedPlan && self.isP2P)
-                        && logger.warn(`${self} Source-add request for existing SSRC: ${ssrc}`);
+                    !self.isP2P && logger.warn(`${self} Source-add request for existing SSRC: ${ssrc}`);
 
                     return;
                 }
      *  in removeSsrcInfo
      */
     _processRemoteRemoveSource(removeSsrcInfo) {
-        const remoteSdp = this.usesUnifiedPlan
-            ? new SDP(this.peerconnection.peerconnection.remoteDescription.sdp)
-            : new SDP(this.peerconnection.remoteDescription.sdp);
+        const remoteSdp = new SDP(this.peerconnection.peerconnection.remoteDescription.sdp);
         let ssrcs;
 
-        removeSsrcInfo.forEach((lines, idx) => {
+        removeSsrcInfo.forEach(lines => {
             // eslint-disable-next-line no-param-reassign
             lines = lines.split('\r\n');
             lines.pop(); // remove empty last element;
             ssrcs = lines.map(line => Number(line.split('a=ssrc:')[1]?.split(' ')[0]));
 
-            if (this.usesUnifiedPlan) {
-                let mid;
-
-                lines.forEach(line => {
-                    mid = remoteSdp.media.findIndex(mLine => mLine.includes(line));
-                    if (mid > -1) {
-                        remoteSdp.media[mid] = remoteSdp.media[mid].replace(`${line}\r\n`, '');
-                        if (this.isP2P) {
-                            const mediaType = SDPUtil.parseMLine(remoteSdp.media[mid].split('\r\n')[0])?.media;
-                            const desiredDirection = this.peerconnection.getDesiredMediaDirection(mediaType, false);
-
-                            [ MediaDirection.SENDRECV, MediaDirection.SENDONLY ].forEach(direction => {
-                                remoteSdp.media[mid] = remoteSdp.media[mid]
-                                    .replace(`a=${direction}`, `a=${desiredDirection}`);
-                            });
-                        } else {
-                            // Jvb connections will have direction set to 'sendonly' for the remote sources.
+            let mid;
+
+            lines.forEach(line => {
+                mid = remoteSdp.media.findIndex(mLine => mLine.includes(line));
+                if (mid > -1) {
+                    remoteSdp.media[mid] = remoteSdp.media[mid].replace(`${line}\r\n`, '');
+                    if (this.isP2P) {
+                        const mediaType = SDPUtil.parseMLine(remoteSdp.media[mid].split('\r\n')[0])?.media;
+                        const desiredDirection = this.peerconnection.getDesiredMediaDirection(mediaType, false);
+
+                        [ MediaDirection.SENDRECV, MediaDirection.SENDONLY ].forEach(direction => {
                             remoteSdp.media[mid] = remoteSdp.media[mid]
-                                .replace(`a=${MediaDirection.SENDONLY}`, `a=${MediaDirection.INACTIVE}`);
+                                .replace(`a=${direction}`, `a=${desiredDirection}`);
+                        });
+                    } else {
+                        // Jvb connections will have direction set to 'sendonly' for the remote sources.
+                        remoteSdp.media[mid] = remoteSdp.media[mid]
+                            .replace(`a=${MediaDirection.SENDONLY}`, `a=${MediaDirection.INACTIVE}`);
 
-                            // Reject the m-line so that the browser removes the associated transceiver from the list
-                            // of available transceivers. This will prevent the client from trying to re-use these
-                            // inactive transceivers when additional video sources are added to the peerconnection.
-                            const { media, port } = SDPUtil.parseMLine(remoteSdp.media[mid].split('\r\n')[0]);
+                        // Reject the m-line so that the browser removes the associated transceiver from the list
+                        // of available transceivers. This will prevent the client from trying to re-use these
+                        // inactive transceivers when additional video sources are added to the peerconnection.
+                        const { media, port } = SDPUtil.parseMLine(remoteSdp.media[mid].split('\r\n')[0]);
 
-                            remoteSdp.media[mid] = remoteSdp.media[mid].replace(`m=${media} ${port}`, `m=${media} 0`);
-                        }
+                        remoteSdp.media[mid] = remoteSdp.media[mid].replace(`m=${media} ${port}`, `m=${media} 0`);
                     }
-                });
-            } else {
-                lines.forEach(line => {
-                    remoteSdp.media[idx] = remoteSdp.media[idx].replace(`${line}\r\n`, '');
-                });
-            }
+                }
+            });
         });
 
         // Update the ssrc owners list.
 
         // Add a new m-line in the remote description if the source info for a secondary video source is recceived from
         // the remote p2p peer when multi-stream support is enabled.
-        if (addSsrcInfo.length > remoteSdp.media.length
-            && this.isP2P
-            && this.usesUnifiedPlan) {
+        if (addSsrcInfo.length > remoteSdp.media.length && this.isP2P) {
             remoteSdp.addMlineForNewLocalSource(MediaType.VIDEO);
             remoteSdp = new SDP(remoteSdp.raw);
         }
 
             // Make sure to change the direction to 'sendrecv/sendonly' only for p2p connections. For jvb connections,
             // a new m-line is added for the new remote sources.
-            if (this.isP2P && this.usesUnifiedPlan) {
+            if (this.isP2P) {
                 const mediaType = SDPUtil.parseMLine(remoteSdp.media[idx].split('\r\n')[0])?.media;
                 const desiredDirection = this.peerconnection.getDesiredMediaDirection(mediaType, true);
 
      * otherwise.
      */
     addTracks(localTracks = null) {
-        if (!FeatureFlags.isMultiStreamSendSupportEnabled()
-            || !localTracks?.length
-            || localTracks.find(track => track.getType() !== MediaType.VIDEO)) {
+        if (!localTracks?.length) {
+            Promise.reject(new Error('No tracks passed'));
+        }
+
+        if (localTracks.find(track => track.getType() !== MediaType.VIDEO)) {
             return Promise.reject(new Error('Multiple tracks of the given media type are not supported'));
         }
 
         const workFunction = finishedCallback => {
             logger.debug(`${this} replaceTrack worker started. oldTrack = ${oldTrack}, newTrack = ${newTrack}`);
 
-            if (!this.usesUnifiedPlan) {
-                // 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();
-                }
-            }
-
             this.peerconnection.replaceTrack(oldTrack, newTrack)
                 .then(shouldRenegotiate => {
                     let promise = Promise.resolve();
         return removeSsrcInfo;
     }
 
-    /**
-     * Will print an error if there is any difference, between the SSRCs given
-     * in the <tt>oldSDP</tt> and the ones currently described in
-     * the peerconnection's local description.
-     * @param {string} operationName the operation's name which will be printed
-     * in the error message.
-     * @param {SDP} oldSDP the old local SDP which will be compared with
-     * the current one.
-     * @return {boolean} <tt>true</tt> if there was any change or <tt>false</tt>
-     * otherwise.
-     * @private
-     */
-    _verifyNoSSRCChanged(operationName, oldSDP) {
-        const currentLocalSDP
-            = new SDP(this.peerconnection.localDescription.sdp);
-        let sdpDiff = new SDPDiffer(oldSDP, currentLocalSDP);
-        const addedMedia = sdpDiff.getNewMedia();
-
-        if (Object.keys(addedMedia).length) {
-            logger.error(`${this} - some SSRC were added on ${operationName}`, addedMedia);
-
-            return false;
-        }
-
-        sdpDiff = new SDPDiffer(currentLocalSDP, oldSDP);
-        const removedMedia = sdpDiff.getNewMedia();
-
-        if (Object.keys(removedMedia).length) {
-            logger.error(`${this} - some SSRCs were removed on ${operationName}`, removedMedia);
-
-            return false;
-        }
-
-        return true;
-    }
-
     /**
      * Adds local track back to the peerconnection associated with this session.
      * @param {JitsiLocalTrack} track
 
                 return;
             }
-            const oldLocalSDP = tpc.localDescription.sdp;
             const operationPromise
                 = isRemove
                     ? tpc.removeTrackFromPc(track)
 
             operationPromise
                 .then(shouldRenegotiate => {
-                    if (shouldRenegotiate && oldLocalSDP && tpc.remoteDescription.sdp) {
-                        this._renegotiate()
-                            .then(() => {
-                                // The results are ignored, as this check failure is not enough to fail the whole
-                                // operation. It will log an error inside for plan-b.
-                                !this.usesUnifiedPlan && this._verifyNoSSRCChanged(operationName, new SDP(oldLocalSDP));
-                                finishedCallback();
-                            });
+                    if (shouldRenegotiate) {
+                        this._renegotiate().then(finishedCallback);
                     } else {
                         finishedCallback();
                     }

package-lock.json

         "@jitsi/logger": "2.0.2",
         "@jitsi/rtcstats": "9.7.0",
         "@jitsi/sdp-interop": "git+https://github.com/jitsi/sdp-interop#3d49eb4aa26863a3f8d32d7581cdb4321244266b",
-        "@jitsi/sdp-simulcast": "0.4.0",
         "@testrtc/watchrtc-sdk": "1.36.3",
         "async-es": "3.2.4",
         "base64-js": "1.3.1",
         "sdp-verify": "checker.js"
       }
     },
-    "node_modules/@jitsi/sdp-simulcast": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@jitsi/sdp-simulcast/-/sdp-simulcast-0.4.0.tgz",
-      "integrity": "sha512-jXJM3/XM853UwPlxhSJx5Fc13G4158RIeTgjis3lA286Y7lp18GOR0xFlRvx/5UyhtE3qT2NzSmAwR+CpJohFw==",
-      "dependencies": {
-        "sdp-transform": "2.3.0"
-      }
-    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
         }
       }
     },
-    "@jitsi/sdp-simulcast": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@jitsi/sdp-simulcast/-/sdp-simulcast-0.4.0.tgz",
-      "integrity": "sha512-jXJM3/XM853UwPlxhSJx5Fc13G4158RIeTgjis3lA286Y7lp18GOR0xFlRvx/5UyhtE3qT2NzSmAwR+CpJohFw==",
-      "requires": {
-        "sdp-transform": "2.3.0"
-      }
-    },
     "@jridgewell/gen-mapping": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",

package.json

     "@jitsi/logger": "2.0.2",
     "@jitsi/rtcstats": "9.7.0",
     "@jitsi/sdp-interop": "git+https://github.com/jitsi/sdp-interop#3d49eb4aa26863a3f8d32d7581cdb4321244266b",
-    "@jitsi/sdp-simulcast": "0.4.0",
     "@testrtc/watchrtc-sdk": "1.36.3",
     "async-es": "3.2.4",
     "base64-js": "1.3.1",

types/hand-crafted/modules/RTC/TraceablePeerConnection.d.ts

 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import JitsiLocalTrack from './JitsiLocalTrack';
 import LocalSdpMunger from '../sdp/LocalSdpMunger';
-import SdpConsistency from '../sdp/SdpConsistency';
 import RtxModifier from '../sdp/RtxModifier';
 import SignalingLayer from '../../service/RTC/SignalingLayer';
 import { MediaType } from '../../service/RTC/MediaType';
   disabledCodec: string;
   preferredCodec: string;
   startSilent: boolean;
-  usesUnifiedPlan: boolean;
 } ): void; // TODO:
 
 export default class TraceablePeerConnection {
   maxstats: unknown; // TODO:
   interop: unknown; // TODO: unknown = Interop refers to @jitsi/sdp-interop
   simulcast: unknown; // TODO: unknown = Simulcast refers to @jitsi/sdp-simulcast
-  sdpConsistency: SdpConsistency; // TODO:
   localSdpMunger: LocalSdpMunger; // TODO:
   eventEmitter: unknown; // TODO:
   rtxModifier: RtxModifier; // TODO:
   setSenderVideoConstraint: ( frameHeight: number ) => Promise<void>;
   setVideoTransferActive: ( active: boolean ) => boolean;
   sendTones: ( tones: string, duration: number, interToneGap: number ) => void;
-  generateRecvonlySsrc: () => void;
-  clearRecvonlySsrc: () => void;
   close: () => void;
   createAnswer: ( constraints: unknown ) => unknown; // TODO:
   createOffer: ( constraints: unknown ) => unknown; // TODO:
   addIceCandidate: ( candidate: unknown ) => unknown; // TODO:
-  generateNewStreamSSRCInfo: (track: JitsiLocalTrack) => TraceablePeerConnection['localSSRCs'];
-  usesUnifiedPlan: () => boolean;
   getStats: () => unknown; // TODO:
   toString: () => string;
 }

types/hand-crafted/modules/browser/BrowserCapabilities.d.ts

   supportsGetDisplayMedia: () => boolean;
   supportsInsertableStreams: () => boolean;
   supportsAudioRed: () => boolean;
-  supportsUnifiedPlan: () => boolean;
   supportsVADDetection: () => boolean;
 }

types/hand-crafted/modules/sdp/LocalSdpMunger.d.ts

 
 export default class LocalSdpMunger {
   constructor( tpc: TraceablePeerConnection, localEndpointId: string );
-  maybeAddMutedLocalVideoTracksToSDP: ( desc: unknown ) => RTCSessionDescription; // TODO:
   transformStreamIdentifiers: ( sessionDesc: RTCSessionDescription ) => RTCSessionDescription;
 }

types/hand-crafted/modules/sdp/SdpConsistency.d.ts

-export default class SdpConsistency {
-  constructor( logPrefix: string );
-  clearVideoSsrcCache: () => void;
-  setPrimarySsrc: ( primarySsrc: number ) => void;
-  hasPrimarySsrcCached: () => void;
-  makeVideoPrimarySsrcsConsistent: ( sdpStr: string ) => string;
-}

types/hand-crafted/modules/xmpp/JingleSessionPC.d.ts

   sendIceFailedNotification: () => void;
   addIceCandidates: ( elem: unknown ) => void; // TODO:
   readSsrcInfo: ( contents: unknown ) => void; // TODO:
-  generateRecvonlySsrc: () => void;
   getConfiguredVideoCodec: () => CodecMimeType;
   acceptOffer: ( jingleOffer: JQuery, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, localTracks?: JitsiLocalTrack[] ) => void; // TODO:
   invite: ( localTracks?: JitsiLocalTrack[] ) => void;