fix(multi-stream-support) Support muting of desktop track.

* fix(multi-stream-support) Support muting of desktop track.

* fix(multi-stream) Always initiate responder renegotiation even for p2p.
This is needed since the new m-line is always added to the remote description.

* fix(multi-stream) Support multi-stream only on Unfied plan endpoints.

* fix(multi-stream) Advertise source-name signaling to Jicofo when supported.

* fix(JitsiLocalTrack): Remove unnecessary reject.

* fix: add the correct source name attribute for the second video track.

* squash: Address review comments.

JitsiConference.js

             return Promise.all(addTrackPromises)
                 .then(() => {
                     this._setupNewTrack(track);
+                    this._sendBridgeVideoTypeMessage(track);
+                    this._updateRoomPresence(this.getActiveMediaSession());
 
-                    // TODO Update presence and sent videoType message.
                     if (this.isMutedByFocus || this.isVideoMutedByFocus) {
                         this._fireMuteChangeEvent(track);
                     }
         logger.warn(`JitsiConference.replaceTrack oldTrack (${oldTrack} does not belong to this conference`);
     }
 
+    if (FeatureFlags.isMultiStreamSupportEnabled() && oldTrack && newTrack && oldTrack.isVideoTrack()) {
+        newTrack.setSourceName(oldTrack.getSourceName());
+    }
+
     // Now replace the stream at the lower levels
     return this._doReplaceTrack(oldTrackBelongsToConference ? oldTrack : null, newTrack)
         .then(() => {

JitsiMeetJS.js

         Settings.init(options.externalStorage);
         Statistics.init(options);
 
+        // Multi-stream is supported only on endpoints running in Unified plan mode and the flag to disable unified
+        // plan also needs to be taken into consideration.
+        if (typeof options.enableUnifiedOnChrome !== 'undefined') {
+            options.flags.enableUnifiedOnChrome = options.enableUnifiedOnChrome;
+        }
+
         // Configure the feature flags.
         FeatureFlags.init(options.flags || { });
 

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) {
+        if (this.isMuted() === muted
+            && !(this.videoType === VideoType.DESKTOP && FeatureFlags.isMultiStreamSupportEnabled())) {
             return Promise.resolve();
         }
 
         // A function that will print info about muted status transition
         const logMuteInfo = () => logger.info(`Mute ${this}: ${muted}`);
 
+        // In the multi-stream mode, desktop tracks are muted from jitsi-meet instead of being removed from the
+        // 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
+                || (this.videoType === VideoType.DESKTOP && !FeatureFlags.isMultiStreamSupportEnabled())
                 || !browser.doesVideoMuteByStreamRemove()) {
             logMuteInfo();
 
                     this._startStreamEffect(this._streamEffect);
                 }
 
-                this.containers.map(
-                    cont => RTCUtils.attachMediaStream(cont, this.stream));
+                this.containers.map(cont => RTCUtils.attachMediaStream(cont, this.stream));
 
                 return this._addStreamToConferenceAsUnmute();
             });

modules/RTC/TPCUtils.js

     replaceTrack(oldTrack, newTrack) {
         const mediaType = newTrack?.getType() ?? oldTrack?.getType();
         const track = newTrack?.getTrack() ?? null;
+        const isNewLocalSource = FeatureFlags.isMultiStreamSupportEnabled()
+            && this.pc.getLocalTracks(mediaType)?.length
+            && !oldTrack
+            && newTrack
+            && !newTrack.conference;
         let transceiver;
 
         // If old track exists, replace the track on the corresponding sender.
         // Find the first recvonly transceiver when more than one track of the same media type is being added to the pc.
         // As part of the track addition, a new m-line was added to the remote description with direction set to
         // recvonly.
-        } else if (FeatureFlags.isMultiStreamSupportEnabled()
-            && this.pc.getLocalTracks(mediaType)?.length
-            && !newTrack.conference) {
+        } else if (isNewLocalSource) {
             transceiver = this.pc.peerconnection.getTransceivers().find(
                 t => t.receiver.track.kind === mediaType
                 && t.direction === MediaDirection.RECVONLY
                 && t.currentDirection === MediaDirection.INACTIVE);
 
-        // For unmute operations, find the transceiver based on the track index in the source name if present, otherwise
-        // it is assumed to be the first local track that was added to the peerconnection.
+        // For mute/unmute operations, find the transceiver based on the track index in the source name if present,
+        // otherwise it is assumed to be the first local track that was added to the peerconnection.
         } else {
             transceiver = this.pc.peerconnection.getTransceivers().find(t => t.receiver.track.kind === mediaType);
-
-            const sourceName = newTrack?.getSourceName();
+            const sourceName = newTrack?.getSourceName() ?? oldTrack?.getSourceName();
 
             if (sourceName) {
                 const trackIndex = Number(sourceName.split('-')[1].substring(1));

modules/RTC/TraceablePeerConnection.js

 TraceablePeerConnection.prototype.removeTrackMute = function(localTrack) {
     const webRtcStream = localTrack.getOriginalStream();
 
-    this.trace(
-        'removeStreamMute',
-        localTrack.rtcId, webRtcStream ? webRtcStream.id : null);
+    this.trace('removeTrackMute', localTrack.rtcId, webRtcStream ? webRtcStream.id : null);
 
-    if (!this._assertTrackBelongs('removeStreamMute', localTrack)) {
+    if (!this._assertTrackBelongs('removeTrackMute', localTrack)) {
         // Abort - nothing to be done here
         return Promise.reject('Track not found in the peerconnection');
     }
         return Promise.resolve(true);
     }
 
-    logger.error(`${this} removeStreamMute - no WebRTC stream for track=${localTrack}`);
+    logger.error(`${this} removeTrackMute - no WebRTC stream for track=${localTrack}`);
 
     return Promise.reject('Stream not found');
 };

modules/flags/FeatureFlags.js

 import { getLogger } from '@jitsi/logger';
 
+import browser from '../browser';
+
 const logger = getLogger('FeatureFlags');
 
 /**
         this._sourceNameSignaling = Boolean(flags.sourceNameSignaling);
         this._sendMultipleVideoStreams = Boolean(flags.sendMultipleVideoStreams);
 
+        // For Chromium, check if Unified plan is enabled.
+        this._usesUnifiedPlan = browser.supportsUnifiedPlan()
+            && (!browser.isChromiumBased() || (flags.enableUnifiedOnChrome ?? true));
+
         logger.info(`Source name signaling: ${this._sourceNameSignaling},`
-            + ` Send multiple video streams: ${this._sendMultipleVideoStreams}`);
+            + ` Send multiple video streams: ${this._sendMultipleVideoStreams},`
+            + ` uses Unified plan: ${this._usesUnifiedPlan}`);
     }
 
     /**
      * @returns {boolean}
      */
     isMultiStreamSupportEnabled() {
-        return this._sourceNameSignaling && this._sendMultipleVideoStreams;
+        return this._sourceNameSignaling && this._sendMultipleVideoStreams && this._usesUnifiedPlan;
     }
 
     /**

modules/sdp/LocalSdpMunger.js

      */
     _generateMsidAttribute(mediaType, trackId, streamId = null) {
         if (!(mediaType && trackId)) {
-            logger.warn(`Unable to munge local MSID - track id=${trackId} or media type=${mediaType} is missing`);
+            logger.error(`Unable to munge local MSID - track id=${trackId} or media type=${mediaType} is missing`);
 
             return null;
         }
                     const trackId = streamAndTrackIDs[1];
 
                     // eslint-disable-next-line max-depth
-                    if (FeatureFlags.isMultiStreamSupportEnabled()
-                        && this.tpc.usesUnifiedPlan()
-                        && mediaType === MediaType.VIDEO) {
+                    if (FeatureFlags.isMultiStreamSupportEnabled() && mediaType === MediaType.VIDEO) {
 
                         // eslint-disable-next-line max-depth
                         if (streamId === '-' || !streamId) {
                 const msidExists = mediaSection.ssrcs
                     .find(ssrc => ssrc.id === source && ssrc.attribute === 'msid');
 
-                if (!msidExists) {
+                if (!msidExists && trackId) {
                     const generatedMsid = this._generateMsidAttribute(mediaType, trackId);
 
                     mediaSection.ssrcs.push({
             this._injectSourceNames(audioMLine);
         }
 
-        const videoMLine = transformer.selectMedia(MediaType.VIDEO)?.[0];
+        const videoMlines = transformer.selectMedia(MediaType.VIDEO);
+
+        if (!FeatureFlags.isMultiStreamSupportEnabled()) {
+            videoMlines.splice(1);
+        }
 
-        if (videoMLine) {
+        for (const videoMLine of videoMlines) {
             this._transformMediaIdentifiers(videoMLine);
             this._injectSourceNames(videoMLine);
         }
 
         for (const source of sources) {
             const nameExists = mediaSection.ssrcs.find(ssrc => ssrc.id === source && ssrc.attribute === 'name');
+            const msid = mediaSection.ssrcs.find(ssrc => ssrc.id === source && ssrc.attribute === 'msid')?.value;
+            const trackIndex = msid ? msid.split('-')[2] : null;
 
             if (!nameExists) {
                 // Inject source names as a=ssrc:3124985624 name:endpointA-v0
                 mediaSection.ssrcs.push({
                     id: source,
                     attribute: 'name',
-                    value: getSourceNameForJitsiTrack(this.localEndpointId, mediaType, 0)
+                    value: getSourceNameForJitsiTrack(this.localEndpointId, mediaType, trackIndex)
                 });
             }
         }

modules/xmpp/JingleSessionPC.js

      * otherwise.
      */
     addTrack(localTrack) {
-        if (!FeatureFlags.isMultiStreamSupportEnabled()
-            || !this.usesUnifiedPlan
-            || localTrack.type !== MediaType.VIDEO) {
+        if (!FeatureFlags.isMultiStreamSupportEnabled() || localTrack.type !== MediaType.VIDEO) {
             return Promise.reject(new Error('Multiple tracks of a given media type are not supported'));
         }
 
 
             // Add a new transceiver by adding a new mline in the remote description.
             remoteSdp.addMlineForNewLocalSource(MediaType.VIDEO);
-            this._renegotiate(remoteSdp.raw)
+
+            // Always initiate a responder renegotiate since the new m-line is added to remote SDP.
+            const remoteDescription = new RTCSessionDescription({
+                type: 'offer',
+                sdp: remoteSdp.raw
+            });
+
+            this._responderRenegotiate(remoteDescription)
                 .then(() => finishedCallback(), error => finishedCallback(error));
         };
 

modules/xmpp/xmpp.js

 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import browser from '../browser';
 import { E2EEncryption } from '../e2ee/E2EEncryption';
+import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
         if (E2EEncryption.isSupported(this.options)) {
             this.caps.addFeature(FEATURE_E2EE, false, true);
         }
+
+        // Advertise source-name signaling when the endpoint supports it.
+        if (FeatureFlags.isSourceNameSignalingEnabled()) {
+            logger.info('Source-name signaling is enabled');
+            this.caps.addFeature('http://jitsi.org/source-name');
+        }
     }
 
     /**

types/auto/modules/flags/FeatureFlags.d.ts

     init(flags: any): void;
     _sourceNameSignaling: boolean;
     _sendMultipleVideoStreams: boolean;
+    _usesUnifiedPlan: any;
     /**
      * Checks if multiple local video streams support is enabled.
      *