fix: Use RTCRtpSender.replaceTrack() for applying presenter effect on FF

JitsiConference.js

@@ -989,6 +989,32 @@ JitsiConference.prototype.replaceTrack = function(oldTrack, newTrack) {
         }, error => Promise.reject(new Error(error)));
 };
 
+/**
+ * Replaces the track at the lower level by going through the Jingle session
+ * and WebRTC peer connection. The track is replaced without the need for an
+ * offer/answer cycle.
+ * @param {JitsiLocalTrack} localTrack - the local track whose media stream has
+ * been updated.
+ */
+JitsiConference.prototype.replaceTrackWithoutOfferAnswer = function(localTrack) {
+    const replaceTrackPromises = [];
+
+    if (this.jvbJingleSession) {
+        replaceTrackPromises.push(
+            this.jvbJingleSession.replaceTrackWithoutOfferAnswer(localTrack));
+    } else {
+        logger.info('replaceTrackWithoutOfferAnswer - no JVB JingleSession');
+    }
+    if (this.p2pJingleSession) {
+        replaceTrackPromises.push(
+            this.p2pJingleSession.replaceTrackWithoutOfferAnswer(localTrack));
+    } else {
+        logger.info('_doReplaceTrack - no P2P JingleSession');
+    }
+
+    return Promise.all(replaceTrackPromises);
+};
+
 /**
  * Replaces the tracks at the lower level by going through the Jingle session
  * and WebRTC peer connection. The method will resolve immediately if there is

modules/RTC/JitsiLocalTrack.js

@@ -338,7 +338,6 @@ export default class JitsiLocalTrack extends JitsiTrack {
         if (this._streamEffect) {
             this._streamEffect.stopEffect();
             this._setStream(this._originalStream);
-            this._originalStream = undefined;
         }
     }
 
@@ -392,6 +391,22 @@ export default class JitsiLocalTrack extends JitsiTrack {
 
         this._setEffectInProgress = true;
 
+        // For firefox/safari, replace the stream without doing a offer answer with the remote peer.
+        if (browser.supportsRtpSender()) {
+            this._switchStreamEffect(effect);
+
+            return conference.replaceTrackWithoutOfferAnswer(this)
+                .then(() => {
+                    this._setEffectInProgress = false;
+                })
+                .catch(error => {
+                    this._setEffectInProgress = false;
+                    this._switchStreamEffect();
+                    logger.error('Failed to switch to the new stream!', error);
+                    throw error;
+                });
+        }
+
         // TODO: Create new JingleSessionPC method for replacing a stream in JitsiLocalTrack without offer answer.
         return conference.removeTrack(this)
             .then(() => {

modules/RTC/TraceablePeerConnection.js

@@ -5,6 +5,7 @@ import transform from 'sdp-transform';
 
 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';
@@ -1546,6 +1547,16 @@ TraceablePeerConnection.prototype.removeTrack = function(localTrack) {
     }
 };
 
+/**
+ * Returns the sender corresponding to the given media type.
+ * @param {MEDIA_TYPE} mediaType - The media type 'audio' or 'video' to be used for the search.
+ * @returns {RTPSender|undefined} - The found sender or undefined if no sender
+ * was found.
+ */
+TraceablePeerConnection.prototype.findSenderByKind = function(mediaType) {
+    return this.peerconnection.getSenders().find(s => s.track && s.track.kind === mediaType);
+};
+
 /**
  * Returns the sender corresponding to the given MediaStream.
  *
@@ -1633,6 +1644,33 @@ TraceablePeerConnection.prototype.replaceTrack = function(oldTrack, newTrack) {
     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

modules/xmpp/JingleSessionPC.js

@@ -1665,6 +1665,19 @@ export default class JingleSessionPC extends JingleSession {
             });
     }
 
+    /**
+     * 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