@webex/web-client-media-engine 3.10.1 → 3.11.1

package/dist/cjs/index.js

@@ -490,6 +490,7 @@ exports.WebrtcCoreErrorType = void 0;
 (function (WebrtcCoreErrorType) {
     WebrtcCoreErrorType["DEVICE_PERMISSION_DENIED"] = "DEVICE_PERMISSION_DENIED";
     WebrtcCoreErrorType["CREATE_STREAM_FAILED"] = "CREATE_STREAM_FAILED";
+    WebrtcCoreErrorType["ADD_EFFECT_FAILED"] = "ADD_EFFECT_FAILED";
 })(exports.WebrtcCoreErrorType || (exports.WebrtcCoreErrorType = {}));
 /**
  * Represents a WebRTC core error, which contains error type and error message.
@@ -1250,11 +1251,12 @@ class _Stream {
 _a$1$1 = exports.StreamEventNames.MuteStateChange, _b$1 = exports.StreamEventNames.Ended;
 const Stream = AddEvents(_Stream);
 
-var _a$6, _b;
+var _a$6, _b, _c;
 exports.LocalStreamEventNames = void 0;
 (function (LocalStreamEventNames) {
     LocalStreamEventNames["ConstraintsChange"] = "constraints-change";
     LocalStreamEventNames["OutputTrackChange"] = "output-track-change";
+    LocalStreamEventNames["EffectAdded"] = "effect-added";
 })(exports.LocalStreamEventNames || (exports.LocalStreamEventNames = {}));
 /**
  * A stream which originates on the local device.
@@ -1269,6 +1271,7 @@ class _LocalStream extends Stream {
         super(stream);
         this[_a$6] = new TypedEvent$1();
         this[_b] = new TypedEvent$1();
+        this[_c] = new TypedEvent$1();
         this.effects = [];
         this.loadingEffects = new Map();
         this.inputStream = stream;
@@ -1360,55 +1363,110 @@ class _LocalStream extends Stream {
     /**
      * Adds an effect to a local stream.
      *
-     * @param name - The name of the effect.
      * @param effect - The effect to add.
      */
-    addEffect(name, effect) {
+    addEffect(effect) {
         return __awaiter$2(this, void 0, void 0, function* () {
-            // Load the effect
-            this.loadingEffects.set(name, effect);
-            const outputTrack = yield effect.load(this.outputTrack);
-            // Check that the loaded effect is the latest one and dispose if not
-            if (effect !== this.loadingEffects.get(name)) {
+            // Check if the effect has already been added.
+            if (this.effects.some((e) => e.id === effect.id)) {
+                return;
+            }
+            // Load the effect. Because loading is asynchronous, keep track of the loading effects.
+            this.loadingEffects.set(effect.kind, effect);
+            yield effect.load(this.outputTrack);
+            // After loading, check whether or not we still want to use this effect. If another effect of
+            // the same kind was added while this effect was loading, we only want to use the latest effect,
+            // so dispose this one. If the effects list was cleared while this effect was loading, also
+            // dispose it.
+            if (effect !== this.loadingEffects.get(effect.kind)) {
                 yield effect.dispose();
-                throw new Error(`Effect "${name}" not required after loading`);
+                throw new WebrtcCoreError(exports.WebrtcCoreErrorType.ADD_EFFECT_FAILED, `Another effect with kind ${effect.kind} was added while effect ${effect.id} was loading, or the effects list was cleared.`);
             }
-            // Use the effect
-            this.loadingEffects.delete(name);
-            this.effects.push({ name, effect });
-            this.changeOutputTrack(outputTrack);
-            // When the effect's track is updated, update the next effect or output stream.
-            // TODO: using EffectEvent.TrackUpdated will cause the entire web-media-effects lib to be built
-            // and makes the size of the webrtc-core build much larger, so we use type assertion here as a
-            // temporary workaround.
-            effect.on('track-updated', (track) => {
-                var _c;
-                const effectIndex = this.effects.findIndex((e) => e.name === name);
+            this.loadingEffects.delete(effect.kind);
+            /**
+             * Handle when the effect's output track has been changed. This will update the input of the
+             * next effect in the effects list of the output of the stream.
+             *
+             * @param track - The new output track of the effect.
+             */
+            const handleEffectTrackUpdated = (track) => {
+                var _d;
+                const effectIndex = this.effects.findIndex((e) => e.id === effect.id);
                 if (effectIndex === this.effects.length - 1) {
                     this.changeOutputTrack(track);
                 }
+                else if (effectIndex >= 0) {
+                    (_d = this.effects[effectIndex + 1]) === null || _d === void 0 ? void 0 : _d.replaceInputTrack(track);
+                }
                 else {
-                    (_c = this.effects[effectIndex + 1]) === null || _c === void 0 ? void 0 : _c.effect.replaceInputTrack(track);
+                    logger$3.error(`Effect with ID ${effect.id} not found in effects list.`);
                 }
-            });
+            };
+            /**
+             * Handle when the effect has been disposed. This will remove all event listeners from the
+             * effect.
+             */
+            const handleEffectDisposed = () => {
+                effect.off('track-updated', handleEffectTrackUpdated);
+                effect.off('disposed', handleEffectDisposed);
+            };
+            // TODO: using EffectEvent.TrackUpdated or EffectEvent.Disposed will cause the entire
+            // web-media-effects lib to be rebuilt and inflates the size of the webrtc-core build, so
+            // we use type assertion here as a temporary workaround.
+            effect.on('track-updated', handleEffectTrackUpdated);
+            effect.on('disposed', handleEffectDisposed);
+            // Add the effect to the effects list. If an effect of the same kind has already been added,
+            // dispose the existing effect and replace it with the new effect. If the existing effect was
+            // enabled, also enable the new effect.
+            const existingEffectIndex = this.effects.findIndex((e) => e.kind === effect.kind);
+            if (existingEffectIndex >= 0) {
+                const [existingEffect] = this.effects.splice(existingEffectIndex, 1, effect);
+                if (existingEffect.isEnabled) {
+                    // If the existing effect is not the first effect in the effects list, then the input of the
+                    // new effect should be the output of the previous effect in the effects list. We know the
+                    // output track of the previous effect must exist because it must have been loaded (and all
+                    // loaded effects have an output track).
+                    const inputTrack = existingEffectIndex === 0
+                        ? this.inputTrack
+                        : this.effects[existingEffectIndex - 1].getOutputTrack();
+                    yield effect.replaceInputTrack(inputTrack);
+                    // Enabling the new effect will trigger the track-updated event, which will handle the new
+                    // effect's updated output track.
+                    yield effect.enable();
+                }
+                yield existingEffect.dispose();
+            }
+            else {
+                this.effects.push(effect);
+            }
+            // Emit an event with the effect so others can listen to the effect events.
+            this[exports.LocalStreamEventNames.EffectAdded].emit(effect);
         });
     }
     /**
-     * Get an effect from the effects list.
+     * Get an effect from the effects list by ID.
      *
-     * @param name - The name of the effect you want to get.
+     * @param id - The id of the effect you want to get.
      * @returns The effect or undefined.
      */
-    getEffect(name) {
-        var _c;
-        return (_c = this.effects.find((e) => e.name === name)) === null || _c === void 0 ? void 0 : _c.effect;
+    getEffectById(id) {
+        return this.effects.find((effect) => effect.id === id);
+    }
+    /**
+     * Get an effect from the effects list by kind.
+     *
+     * @param kind - The kind of the effect you want to get.
+     * @returns The effect or undefined.
+     */
+    getEffectByKind(kind) {
+        return this.effects.find((effect) => effect.kind === kind);
     }
     /**
      * Get all the effects from the effects list.
      *
-     * @returns A list of effect items, each containing the name and the effect itself.
+     * @returns A list of effects.
      */
-    getAllEffects() {
+    getEffects() {
         return this.effects;
     }
     /**
@@ -1420,13 +1478,13 @@ class _LocalStream extends Stream {
             // Dispose of any effects currently in use
             if (this.effects.length > 0) {
                 this.changeOutputTrack(this.inputTrack);
-                yield Promise.all(this.effects.map((item) => item.effect.dispose()));
+                yield Promise.all(this.effects.map((effect) => effect.dispose()));
                 this.effects = [];
             }
         });
     }
 }
-_a$6 = exports.LocalStreamEventNames.ConstraintsChange, _b = exports.LocalStreamEventNames.OutputTrackChange;
+_a$6 = exports.LocalStreamEventNames.ConstraintsChange, _b = exports.LocalStreamEventNames.OutputTrackChange, _c = exports.LocalStreamEventNames.EffectAdded;
 const LocalStream = AddEvents(_LocalStream);
 
 /**
@@ -9038,6 +9096,18 @@ function parse(sdp, grammar = DefaultSdpGrammar) {
     const parsed = parseToModel(lines);
     return parsed;
 }
+
+function disableRtcpFbValue(sdpOrAv, rtcpFbValue) {
+    const mediaDescriptions = sdpOrAv instanceof Sdp ? sdpOrAv.avMedia : [sdpOrAv];
+    mediaDescriptions.forEach((media) => {
+        media.codecs.forEach((codec) => {
+            codec.feedback = codec.feedback.filter((fb) => fb !== rtcpFbValue);
+        });
+    });
+}
+function disableTwcc(sdpOrAv) {
+    disableRtcpFbValue(sdpOrAv, 'transport-cc');
+}
 function removeCodec(sdpOrAv, codecName) {
     const mediaDescriptions = sdpOrAv instanceof Sdp ? sdpOrAv.avMedia : [sdpOrAv];
     mediaDescriptions.forEach((media) => {
@@ -9379,7 +9449,7 @@ class EgressSdpMunger {
     reset() {
         this.streamIds = [];
     }
-    mungeLocalDescription(mediaDescription, simulcastEnabled, rtxEnabled) {
+    mungeLocalDescription(mediaDescription, simulcastEnabled, rtxEnabled, twccDisabled) {
         var _a;
         retainCodecs(mediaDescription, ['h264', 'opus', 'rtx']);
         if (mediaDescription.codecs.size === 0) {
@@ -9457,6 +9527,9 @@ class EgressSdpMunger {
             mediaDescription.addLine(new SsrcGroupLine('SIM', this.streamIds.map((streamId) => streamId.ssrc)));
         }
         applyFormatParameters(mediaDescription, this.customCodecParameters);
+        if (twccDisabled) {
+            disableTwcc(mediaDescription);
+        }
     }
     mungeLocalDescriptionForRemoteServer(mediaDescription, mediaContent, csi) {
         injectContentType(mediaDescription, mediaContent);
@@ -9983,13 +10056,16 @@ class IngressSdpMunger {
     getReceiverId() {
         return Object.assign({ ssrc: this.ssrc }, (this.rtxSsrc ? { rtxSsrc: this.rtxSsrc } : {}));
     }
-    mungeLocalDescription(mediaDescription) {
+    mungeLocalDescription(mediaDescription, twccDisabled) {
         retainCodecs(mediaDescription, ['h264', 'opus', 'rtx']);
         if (mediaDescription.codecs.size === 0) {
             logErrorAndThrow(exports.WcmeErrorType.SDP_MUNGE_MISSING_CODECS, `No codecs present in m-line with MID ${mediaDescription.mid} after filtering.`);
         }
         mediaDescription.bandwidth = new BandwidthLine('TIAS', 20000000);
         removeMidRidExtensions(mediaDescription);
+        if (twccDisabled) {
+            disableTwcc(mediaDescription);
+        }
     }
     mungeRemoteDescription(mediaDescription) {
         if (!mediaDescription.ssrcs.length) {
@@ -10139,6 +10215,7 @@ ReceiveSlot.Events = exports.ReceiveSlotEvents;
 
 class Transceiver {
     constructor(rtcRtpTransceiver, mid) {
+        this.twccDisabled = false;
         this._rtcRtpTransceiver = rtcRtpTransceiver;
         this.mid = mid;
     }
@@ -10182,7 +10259,7 @@ class ReceiveOnlyTransceiver extends Transceiver {
         return this.receiver.getStats();
     }
     mungeLocalDescription(mediaDescription) {
-        this.munger.mungeLocalDescription(mediaDescription);
+        this.munger.mungeLocalDescription(mediaDescription, this.twccDisabled);
     }
     mungeRemoteDescription(mediaDescription) {
         this.munger.mungeRemoteDescription(mediaDescription);
@@ -14045,7 +14122,7 @@ class SendOnlyTransceiver extends Transceiver {
         return params.encodings.length > 1;
     }
     mungeLocalDescription(mediaDescription) {
-        this.munger.mungeLocalDescription(mediaDescription, this.isSimulcastEnabled(), this.rtxEnabled);
+        this.munger.mungeLocalDescription(mediaDescription, this.isSimulcastEnabled(), this.rtxEnabled, this.twccDisabled);
     }
     mungeLocalDescriptionForRemoteServer(mediaDescription) {
         this.munger.mungeLocalDescriptionForRemoteServer(mediaDescription, getMediaContent(this.mediaType), this.csi);
@@ -14231,6 +14308,7 @@ const defaultMultistreamConnectionOptions = {
     bundlePolicy: 'max-compat',
     iceServers: undefined,
     disableContentSimulcast: true,
+    disableAudioTwcc: true,
 };
 class MultistreamConnection extends EventEmitter$2 {
     constructor(userOptions = {}) {
@@ -14308,6 +14386,8 @@ class MultistreamConnection extends EventEmitter$2 {
                 'max-fs': `${defaultMaxVideoEncodeFrameSize}`,
             });
         }
+        transceiver.twccDisabled =
+            getMediaFamily(mediaType) === exports.MediaFamily.Audio ? this.options.disableAudioTwcc : false;
         transceiver.active = false;
         transceiver.streamMuteStateChange.on(() => {
             this.sendSourceAdvertisement(mediaType);
@@ -14568,6 +14648,8 @@ class MultistreamConnection extends EventEmitter$2 {
                     const transceiverMid = this.midPredictor.getNextMid(mediaType);
                     const munger = new IngressSdpMunger();
                     const recvOnlyTransceiver = new ReceiveOnlyTransceiver(rtcRtpTransceiver, transceiverMid, munger);
+                    recvOnlyTransceiver.twccDisabled =
+                        getMediaFamily(mediaType) === exports.MediaFamily.Audio ? this.options.disableAudioTwcc : false;
                     this.recvTransceivers.set(mediaType, [
                         ...(this.recvTransceivers.get(mediaType) || []),
                         recvOnlyTransceiver,