@webex/web-client-media-engine 2.1.1 → 2.1.3

package/dist/esm/index.js

@@ -8855,6 +8855,30 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 class EventEmitter extends events.exports.EventEmitter {
 }
 
+class MidPredictor {
+    constructor() {
+        this.currentMid = 0;
+        this.midMap = new Map();
+    }
+    getNextMid(mediaType) {
+        const mid = this.currentMid++;
+        const mids = this.midMap.get(mediaType) || [];
+        mids.push(`${mid}`);
+        this.midMap.set(mediaType, mids);
+        return `${mid}`;
+    }
+    allocateMidForDatachannel() {
+        this.currentMid += 1;
+    }
+    reset() {
+        this.midMap = new Map();
+        this.currentMid = 0;
+    }
+    getMidMap() {
+        return this.midMap;
+    }
+}
+
 var OveruseState;
 (function (OveruseState) {
     OveruseState[OveruseState["NOT_OVERUSED"] = 0] = "NOT_OVERUSED";
@@ -8962,8 +8986,9 @@ class ReceiveSlot extends EventEmitter {
 ReceiveSlot.Events = ReceiveSlotEvents;
 
 class Transceiver {
-    constructor(rtcRtpTransceiver) {
+    constructor(rtcRtpTransceiver, mid) {
         this._rtcRtpTransceiver = rtcRtpTransceiver;
+        this.mid = mid;
     }
     replaceTransceiver(newRtcRtpTransceiver) {
         this._rtcRtpTransceiver = newRtcRtpTransceiver;
@@ -8974,22 +8999,20 @@ class Transceiver {
     get sender() {
         return this._rtcRtpTransceiver.sender;
     }
-    get mid() {
-        return this._rtcRtpTransceiver.mid;
-    }
     close() {
         this._rtcRtpTransceiver.stop();
     }
 }
 
 class ReceiveOnlyTransceiver extends Transceiver {
-    constructor(rtcRtpTransceiver, idGetter) {
-        super(rtcRtpTransceiver);
+    constructor(rtcRtpTransceiver, mid, signaler) {
+        super(rtcRtpTransceiver, mid);
+        this.streamSignaler = signaler;
         this._receiveSlot = new ReceiveSlot(() => {
             if (!this._rtcRtpTransceiver.mid) {
                 return null;
             }
-            return idGetter(this._rtcRtpTransceiver.mid);
+            return this.streamSignaler.getReceiverId();
         }, this._rtcRtpTransceiver.receiver.track);
     }
     replaceTransceiver(newRtcRtpTransceiver) {
@@ -9006,62 +9029,21 @@ class ReceiveOnlyTransceiver extends Transceiver {
     getStats() {
         return this.receiver.getStats();
     }
+    signalLocalStreams(mLine) {
+        this.streamSignaler.signalLocalStreams(mLine);
+    }
+    signalRemoteStreams(mLine) {
+        this.streamSignaler.signalRemoteStreams(mLine);
+    }
+    get receiverId() {
+        return this.streamSignaler.getReceiverId();
+    }
+    resetStreamSignaler() {
+        this.streamSignaler.reset();
+    }
 }
 ReceiveOnlyTransceiver.rid = '1';
 
-function deepCopy(source) {
-    return Array.isArray(source)
-        ? source.map((item) => deepCopy(item))
-        : source instanceof Map
-            ? new Map(source)
-            : source instanceof Date
-                ? new Date(source.getTime())
-                : source && typeof source === 'object'
-                    ? Object.getOwnPropertyNames(source).reduce((o, prop) => {
-                        Object.defineProperty(o, prop, Object.getOwnPropertyDescriptor(source, prop));
-                        o[prop] = deepCopy(source[prop]);
-                        return o;
-                    }, Object.create(Object.getPrototypeOf(source)))
-                    : source;
-}
-
-function matchMlinesInAnswer(parsedOffer, parsedAnswer, streamSignalerManager) {
-    parsedAnswer.session.groups = parsedOffer.session.groups;
-    parsedAnswer.media = parsedOffer.media.map((offerMline) => {
-        if (!offerMline.mid) {
-            throw new Error(`Offer mline is missing MID`);
-        }
-        const answerMline = parsedAnswer.media.find((m) => m.mid === offerMline.mid);
-        if (answerMline) {
-            if (answerMline instanceof AvMediaDescription) {
-                [...answerMline.codecs.values()].forEach((ci) => {
-                    ci.fmtParams.set('x-google-start-bitrate', '60000');
-                });
-            }
-            return answerMline;
-        }
-        if (!(offerMline instanceof AvMediaDescription)) {
-            throw new Error(`Answer is missing a non-media mline: ${offerMline.mid}`);
-        }
-        const startingMline = parsedAnswer.avMedia.find((m) => m.type === offerMline.type);
-        if (!startingMline) {
-            throw new Error(`Answer has no mline of type ${offerMline.type}, can't generate synthetic answer mline for mid ${offerMline.mid}`);
-        }
-        const fakeCorrespondingMline = deepCopy(startingMline);
-        fakeCorrespondingMline.mid = offerMline.mid;
-        fakeCorrespondingMline.simulcast = undefined;
-        if (offerMline.direction === 'sendrecv' || offerMline.direction === 'sendonly') {
-            fakeCorrespondingMline.direction = 'recvonly';
-        }
-        if (offerMline.direction === 'recvonly') {
-            fakeCorrespondingMline.direction = 'sendonly';
-            const ingressSignaler = streamSignalerManager.getIngressStreamSignalerOrThrow(offerMline.mid);
-            ingressSignaler.signalRemoteStreams(fakeCorrespondingMline);
-        }
-        return fakeCorrespondingMline;
-    });
-}
-
 class JmpLine extends Line {
     constructor(versions) {
         super();
@@ -9235,9 +9217,6 @@ function injectDummyCandidates(parsedSdp) {
         }
     });
 }
-function hasSimulcast(av) {
-    return !!av.simulcast || av.ssrcGroups.map((sg) => sg.semantics).some((sem) => sem === 'SIM');
-}
 function addVlaExtension(mLine) {
     const vlaUri = 'http://www.webrtc.org/experiments/rtp-hdrext/video-layers-allocation00';
     if (mLine.extMaps.findIndex((extMapLine) => extMapLine.uri === vlaUri) === -1) {
@@ -9247,13 +9226,147 @@ function addVlaExtension(mLine) {
     }
 }
 
+const simulcastMaxFrameSizes = {
+    0: '240',
+    1: '2304',
+    2: '8160',
+};
+
+class RidIngressStreamSignaler {
+    constructor(mid) {
+        this.mid = mid;
+    }
+    getReceiverId() {
+        return {
+            mid: this.mid,
+            rid: '1',
+        };
+    }
+    signalLocalStreams(mLine) {
+    }
+    signalRemoteStreams(mLine) {
+    }
+    reset() {
+    }
+}
+class RidEgressStreamSignaler {
+    constructor(mid) {
+        this.streamIds = [];
+        this.mid = mid;
+    }
+    signalStreams(simulcastEnabled, _rtxEnabled, mLine) {
+        mLine.ssrcGroups = [];
+        if (this.streamIds.length === 0) {
+            if (simulcastEnabled) {
+                this.streamIds = [
+                    {
+                        mid: this.mid,
+                        rid: 'low',
+                    },
+                    {
+                        mid: this.mid,
+                        rid: 'medium',
+                    },
+                    {
+                        mid: this.mid,
+                        rid: 'high',
+                    },
+                ];
+            }
+            else {
+                this.streamIds = [
+                    {
+                        mid: this.mid,
+                    },
+                ];
+            }
+        }
+        if (simulcastEnabled) {
+            mLine.rids = this.streamIds.map((streamId, index) => new RidLine(streamId.rid, 'send', `max-fs=${simulcastMaxFrameSizes[index]}`));
+            mLine.simulcast = new SimulcastLine(SimulcastLayerList.fromString('low;medium;high'), new SimulcastLayerList());
+            addVlaExtension(mLine);
+        }
+    }
+    getSenderIds() {
+        return this.streamIds;
+    }
+    reset() {
+        this.streamIds = [];
+    }
+    getEncodingIndexForStreamId(streamId) {
+        return this.streamIds.findIndex((currStreamId) => compareStreamIds(currStreamId, streamId));
+    }
+    setCodecParameters(parameters) {
+    }
+    deleteCodecParameters(parameters) {
+    }
+}
+
+function deepCopy(source) {
+    return Array.isArray(source)
+        ? source.map((item) => deepCopy(item))
+        : source instanceof Map
+            ? new Map(source)
+            : source instanceof Date
+                ? new Date(source.getTime())
+                : source && typeof source === 'object'
+                    ? Object.getOwnPropertyNames(source).reduce((o, prop) => {
+                        Object.defineProperty(o, prop, Object.getOwnPropertyDescriptor(source, prop));
+                        o[prop] = deepCopy(source[prop]);
+                        return o;
+                    }, Object.create(Object.getPrototypeOf(source)))
+                    : source;
+}
+
+function matchMlinesInAnswer(parsedOffer, parsedAnswer, recvTransceiversByMid) {
+    parsedAnswer.session.groups = parsedOffer.session.groups;
+    parsedAnswer.media = parsedOffer.media.map((offerMline) => {
+        if (!offerMline.mid) {
+            throw new Error(`Offer mline is missing MID`);
+        }
+        const answerMline = parsedAnswer.media.find((m) => m.mid === offerMline.mid);
+        if (answerMline) {
+            if (answerMline instanceof AvMediaDescription) {
+                [...answerMline.codecs.values()].forEach((ci) => {
+                    ci.fmtParams.set('x-google-start-bitrate', '60000');
+                });
+            }
+            return answerMline;
+        }
+        if (!(offerMline instanceof AvMediaDescription)) {
+            throw new Error(`Answer is missing a non-media mline: ${offerMline.mid}`);
+        }
+        const startingMline = parsedAnswer.avMedia.find((m) => m.type === offerMline.type);
+        if (!startingMline) {
+            throw new Error(`Answer has no mline of type ${offerMline.type}, can't generate synthetic answer mline for mid ${offerMline.mid}`);
+        }
+        const fakeCorrespondingMline = deepCopy(startingMline);
+        fakeCorrespondingMline.mid = offerMline.mid;
+        fakeCorrespondingMline.simulcast = undefined;
+        if (offerMline.direction === 'sendrecv' || offerMline.direction === 'sendonly') {
+            fakeCorrespondingMline.direction = 'recvonly';
+        }
+        if (offerMline.direction === 'recvonly') {
+            fakeCorrespondingMline.direction = 'sendonly';
+            const recvTransceiver = recvTransceiversByMid.get(offerMline.mid);
+            if (!recvTransceiver) {
+                throw new Error(`Can't find recv transceiver for mid ${offerMline.mid}`);
+            }
+            recvTransceiver.signalRemoteStreams(fakeCorrespondingMline);
+        }
+        return fakeCorrespondingMline;
+    });
+}
+
 class SendOnlyTransceiver extends Transceiver {
-    constructor(rtcpRtpTransceiver, csi) {
-        super(rtcpRtpTransceiver);
+    constructor(rtcpRtpTransceiver, mid, csi, signaler) {
+        super(rtcpRtpTransceiver, mid);
+        this.rtxEnabled = false;
         this.requested = false;
         this.csi = csi;
         this.direction = 'sendrecv';
         this.handleTrackChange = this.handleTrackChange.bind(this);
+        this.streamSignaler = signaler;
     }
     handleTrackChange() {
         var _a;
@@ -9332,88 +9445,27 @@ class SendOnlyTransceiver extends Transceiver {
             yield this.sender.setParameters(sendParameters);
         });
     }
-}
-
-class StatsManager {
-    constructor(statsGetter, statsPreprocessor = () => __awaiter(this, void 0, void 0, function* () { })) {
-        this.statsGetter = statsGetter;
-        this.statsPreProcessor = statsPreprocessor;
+    isSimulcastEnabled() {
+        const params = this.sender.getParameters();
+        return params.encodings.length > 1;
     }
-    getStats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statsReport = yield this.statsGetter();
-            const statsMap = new Map();
-            statsReport.forEach((stats, key) => statsMap.set(key, stats));
-            yield this.statsPreProcessor(statsMap);
-            return statsMap;
-        });
+    signalStreams(mLine) {
+        this.streamSignaler.signalStreams(this.isSimulcastEnabled(), this.rtxEnabled, mLine);
     }
-}
-
-const simulcastMaxFrameSizes = {
-    0: '240',
-    1: '2304',
-    2: '8160',
-};
-
-class RidIngressStreamSignaler {
-    constructor(mid) {
-        this.mid = mid;
+    get senderIds() {
+        return this.streamSignaler.getSenderIds();
     }
-    getReceiverId() {
-        return {
-            mid: this.mid,
-            rid: '1',
-        };
+    getEncodingIndexForStreamId(id) {
+        return this.streamSignaler.getEncodingIndexForStreamId(id);
     }
-    signalLocalStreams(mLine) {
+    resetStreamSignaler() {
+        this.streamSignaler.reset();
     }
-    signalRemoteStreams(mLine) {
-    }
-}
-class RidEgressStreamSignaler {
-    constructor(mid) {
-        this.streamIds = [];
-        this.mid = mid;
+    setCodecParameters(parameters) {
+        this.streamSignaler.setCodecParameters(parameters);
     }
-    signalStreams(simulcastEnabled, _rtxEnabled, mLine) {
-        mLine.ssrcGroups = [];
-        if (this.streamIds.length === 0) {
-            if (simulcastEnabled) {
-                this.streamIds = [
-                    {
-                        mid: this.mid,
-                        rid: 'low',
-                    },
-                    {
-                        mid: this.mid,
-                        rid: 'medium',
-                    },
-                    {
-                        mid: this.mid,
-                        rid: 'high',
-                    },
-                ];
-            }
-            else {
-                this.streamIds = [
-                    {
-                        mid: this.mid,
-                    },
-                ];
-            }
-        }
-        if (simulcastEnabled) {
-            mLine.rids = this.streamIds.map((streamId, index) => new RidLine(streamId.rid, 'send', `max-fs=${simulcastMaxFrameSizes[index]}`));
-            mLine.simulcast = new SimulcastLine(SimulcastLayerList.fromString('low;medium;high'), new SimulcastLayerList());
-            addVlaExtension(mLine);
-        }
-    }
-    getSenderIds() {
-        return this.streamIds;
-    }
-    getEncodingIndexForStreamId(streamId) {
-        return this.streamIds.findIndex((currStreamId) => compareStreamIds(currStreamId, streamId));
+    deleteCodecParameters(parameters) {
+        this.streamSignaler.deleteCodecParameters(parameters);
     }
 }
 
@@ -9421,6 +9473,20 @@ function generateSsrc() {
     return Math.floor(Math.random() * 0xffffffff) + 1;
 }
 
+function setCustomCodecParams(mLine, paramsMap) {
+    paramsMap.forEach((value, param) => {
+        [...mLine.codecs.values()]
+            .filter((ci) => ci.name === 'H264' || ci.name === 'opus')
+            .forEach((ci) => {
+            if (value === null) {
+                ci.fmtParams.delete(param);
+            }
+            else {
+                ci.fmtParams.set(param, `${value}`);
+            }
+        });
+    });
+}
 class SsrcIngressStreamSignaler {
     constructor() {
         this.ssrc = generateSsrc();
@@ -9443,10 +9509,17 @@ class SsrcIngressStreamSignaler {
             mLine.addLine(new SsrcGroupLine('FID', [this.ssrc, this.rtxSsrc]));
         }
     }
+    reset() {
+        this.ssrc = generateSsrc();
+    }
 }
 class SsrcEgressStreamSignaler {
     constructor() {
         this.streamIds = [];
+        this.customCodecParameters = new Map();
+    }
+    reset() {
+        this.streamIds = [];
     }
     signalStreams(simulcastEnabled, rtxEnabled, mLine) {
         var _a;
@@ -9516,6 +9589,7 @@ class SsrcEgressStreamSignaler {
             mLine.addLine(new SsrcGroupLine('SIM', this.streamIds.map((streamId) => streamId.ssrc)));
             addVlaExtension(mLine);
         }
+        setCustomCodecParams(mLine, this.customCodecParameters);
     }
     getSenderIds() {
         return this.streamIds;
@@ -9523,64 +9597,31 @@ class SsrcEgressStreamSignaler {
     getEncodingIndexForStreamId(streamId) {
         return this.streamIds.findIndex((currStreamId) => compareStreamIds(currStreamId, streamId));
     }
-}
-
-class StreamSignalerManager {
-    constructor(streamSignalingMode) {
-        this.egressStreamSignalersByMid = new Map();
-        this.ingressStreamsSignalersByMid = new Map();
-        this.ingressStreamSignalingMode = streamSignalingMode;
-        this.egressStreamSignalingMode = streamSignalingMode;
-    }
-    getOrCreateEgressStreamSignaler(mid) {
-        const existing = this.getEgressStreamSignaler(mid);
-        if (existing) {
-            return existing;
-        }
-        let newSignaler;
-        if (this.egressStreamSignalingMode === 'MID-RID') {
-            newSignaler = new RidEgressStreamSignaler(mid);
-        }
-        else {
-            newSignaler = new SsrcEgressStreamSignaler();
-        }
-        this.egressStreamSignalersByMid.set(mid, newSignaler);
-        return newSignaler;
-    }
-    getEgressStreamSignalerOrThrow(mid) {
-        const existing = this.getEgressStreamSignaler(mid);
-        if (!existing) {
-            throw new Error(`Couldn't find EgressStreamSignaler for mid ${mid}`);
-        }
-        return existing;
-    }
-    getEgressStreamSignaler(mid) {
-        return this.egressStreamSignalersByMid.get(mid);
+    setCodecParameters(parameters) {
+        Object.entries(parameters).forEach(([param, value]) => {
+            this.customCodecParameters.set(param, value);
+        });
     }
-    getOrCreateIngressStreamSignaler(mid) {
-        const existing = this.getIngressStreamSignaler(mid);
-        if (existing) {
-            return existing;
-        }
-        let newSignaler;
-        if (this.ingressStreamSignalingMode === 'MID-RID') {
-            newSignaler = new RidIngressStreamSignaler(mid);
-        }
-        else {
-            newSignaler = new SsrcIngressStreamSignaler();
-        }
-        this.ingressStreamsSignalersByMid.set(mid, newSignaler);
-        return newSignaler;
+    deleteCodecParameters(parameters) {
+        parameters.forEach((param) => {
+            this.customCodecParameters.set(param, null);
+        });
     }
-    getIngressStreamSignaler(mid) {
-        return this.ingressStreamsSignalersByMid.get(mid);
+}
+
+class StatsManager {
+    constructor(statsGetter, statsPreprocessor = () => __awaiter(this, void 0, void 0, function* () { })) {
+        this.statsGetter = statsGetter;
+        this.statsPreProcessor = statsPreprocessor;
     }
-    getIngressStreamSignalerOrThrow(mid) {
-        const existing = this.getIngressStreamSignaler(mid);
-        if (!existing) {
-            throw new Error(`Couldn't find IngressStreamSignaler for mid ${mid}`);
-        }
-        return existing;
+    getStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const statsReport = yield this.statsGetter();
+            const statsMap = new Map();
+            statsReport.forEach((stats, key) => statsMap.set(key, stats));
+            yield this.statsPreProcessor(statsMap);
+            return statsMap;
+        });
     }
 }
 
@@ -13184,6 +13225,24 @@ function webRtcVideoContentHintToJmpVideoContentHint(hint) {
     }
     return undefined;
 }
+function createEgressStreamSignaler(signalingMode, mid) {
+    if (signalingMode === 'MID-RID') {
+        return new RidEgressStreamSignaler(mid);
+    }
+    if (signalingMode === 'SSRC') {
+        return new SsrcEgressStreamSignaler();
+    }
+    throw new Error(`unknown signaling mode`);
+}
+function createIngressStreamSignaler(signalingMode, mid) {
+    if (signalingMode === 'MID-RID') {
+        return new RidIngressStreamSignaler(mid);
+    }
+    if (signalingMode === 'SSRC') {
+        return new SsrcIngressStreamSignaler();
+    }
+    throw new Error(`unknown signaling mode`);
+}
 function toMediaFamily(kind) {
     if (kind === MediaStreamTrackKind.Video) {
         return MediaFamily.Video;
@@ -13217,14 +13276,11 @@ class MultistreamConnection extends EventEmitter {
         this.pendingJmpTasks = [];
         this.metricsCallback = () => { };
         this.overuseUpdateCallback = () => { };
-        this.customCodecParameters = new Map();
-        this.midMap = new Map();
-        this.currentMid = 0;
+        this.midPredictor = new MidPredictor();
         this.offerAnswerQueue = new AsyncQueue();
         this.options = Object.assign(Object.assign({}, defaultMultistreamConnectionOptions), userOptions);
         logger.info(`Creating multistream connection with options ${JSON.stringify(this.options)}`);
         this.initializePeerConnection();
-        this.streamSignalerManager = new StreamSignalerManager(this.options.streamSignalingMode);
         this.overuseStateManager = new OveruseStateManager((overuseState) => this.overuseUpdateCallback(overuseState));
         this.overuseStateManager.start();
         this.statsManager = new StatsManager(() => this.pc.getStats(), (stats) => this.preProcessStats(stats));
@@ -13241,16 +13297,6 @@ class MultistreamConnection extends EventEmitter {
             this.createSendTransceiver(MediaType.AudioSlides, contentSceneId);
         }
     }
-    addMid(mediaType) {
-        const mid = this.currentMid++;
-        const mids = this.midMap.get(mediaType) || [];
-        mids.push(`${mid}`);
-        this.midMap.set(mediaType, mids);
-    }
-    clearMids() {
-        this.midMap = new Map();
-        this.currentMid = 0;
-    }
     initializePeerConnection() {
         var _a;
         (_a = this.pc) === null || _a === void 0 ? void 0 : _a.close();
@@ -13289,9 +13335,18 @@ class MultistreamConnection extends EventEmitter {
             logger.error(`addTransceiver failed due to : ${e}`);
             throw e;
         }
-        this.addMid(mediaType);
+        const mid = this.midPredictor.getNextMid(mediaType);
         const csi = generateCsi(getMediaFamily(mediaType), sceneId);
-        this.sendTransceivers.set(mediaType, new SendOnlyTransceiver(rtcTransceiver, csi));
+        const signaler = createEgressStreamSignaler(this.options.streamSignalingMode, mid);
+        const transceiver = new SendOnlyTransceiver(rtcTransceiver, mid, csi, signaler);
+        if (getMediaFamily(mediaType) === MediaFamily.Video) {
+            transceiver.rtxEnabled = true;
+            transceiver.setCodecParameters({
+                'max-mbps': `${defaultMaxVideoEncodeMbps}`,
+                'max-fs': `${defaultMaxVideoEncodeFrameSize}`,
+            });
+        }
+        this.sendTransceivers.set(mediaType, transceiver);
         this.createJmpSession(mediaType);
     }
     createJmpSession(mediaType) {
@@ -13339,7 +13394,6 @@ class MultistreamConnection extends EventEmitter {
     }
     updateRequestedStreams(mediaType, requests) {
         const sendTransceiver = this.getSendTransceiverOrThrow(mediaType);
-        const signaler = this.streamSignalerManager.getEgressStreamSignalerOrThrow(sendTransceiver.mid);
         const mediaFamily = getMediaFamily(mediaType);
         const requestedIdEncodingParamsMap = new Map();
         const rsRequests = requests.filter((r) => isValidReceiverSelectedInfo(r.policySpecificInfo));
@@ -13360,11 +13414,9 @@ class MultistreamConnection extends EventEmitter {
             }
             const id = ids[0];
             const codecInfo = codecInfos[0];
-            const streamIdsMatched = signaler
-                .getSenderIds()
-                .some((validId) => compareStreamIds(id, validId));
+            const streamIdsMatched = sendTransceiver.senderIds.some((validId) => compareStreamIds(id, validId));
             if (streamIdsMatched) {
-                const encodingIndex = signaler.getEncodingIndexForStreamId(id);
+                const encodingIndex = sendTransceiver.getEncodingIndexForStreamId(id);
                 if (encodingIndex !== -1) {
                     const encodingParams = { maxPayloadBitsPerSecond };
                     if (mediaFamily === MediaFamily.Video) {
@@ -13446,10 +13498,6 @@ class MultistreamConnection extends EventEmitter {
             return;
         }
         const streamStates = this.getVideoStreamStates(mediaType);
-        if (streamStates === null) {
-            logger.debug(`Empty streamStates, not sending MediaRequestStatus`);
-            return;
-        }
         const task = () => {
             var _a;
             (_a = this.jmpSessions.get(mediaType)) === null || _a === void 0 ? void 0 : _a.sendMediaRequestStatus(streamStates);
@@ -13543,13 +13591,10 @@ class MultistreamConnection extends EventEmitter {
                 track.off(LocalTrack.Events.Muted, onTrackMute);
                 track.off(LocalTrack.Events.PublishedStateUpdate, onTrackPublish);
                 track.off(LocalTrack.Events.TrackConstraintsChange, onTrackResolutionChange);
-                if (!track.muted) {
-                    this.sendSourceAdvertisement(mediaType);
-                    this.sendMediaRequestStatus(mediaType);
-                }
             }
-            else if (!track.muted) {
+            if (!track.muted) {
                 this.sendSourceAdvertisement(mediaType);
+                this.sendMediaRequestStatus(mediaType);
             }
         };
         track.on(LocalTrack.Events.PublishedStateUpdate, onTrackPublish);
@@ -13557,14 +13602,10 @@ class MultistreamConnection extends EventEmitter {
     getVideoStreamStates(mediaType) {
         var _a, _b, _c;
         const sendTransceiver = this.getSendTransceiverOrThrow(mediaType);
-        const signaler = this.streamSignalerManager.getEgressStreamSignaler(sendTransceiver.mid);
-        if (!signaler) {
-            return null;
-        }
         const activeSimulcastLayerNumber = ((_a = sendTransceiver.publishedTrack) === null || _a === void 0 ? void 0 : _a.getNumActiveSimulcastLayers()) || 0;
         const published = (_b = sendTransceiver.publishedTrack) === null || _b === void 0 ? void 0 : _b.published;
         const muted = ((_c = sendTransceiver.publishedTrack) === null || _c === void 0 ? void 0 : _c.muted) === true;
-        return signaler.getSenderIds().map((id) => {
+        return sendTransceiver.senderIds.map((id) => {
             let state;
             if (!published) {
                 state = 'no source';
@@ -13572,7 +13613,7 @@ class MultistreamConnection extends EventEmitter {
             else if (muted) {
                 state = 'avatar';
             }
-            else if (activeSimulcastLayerNumber < signaler.getEncodingIndexForStreamId(id)) {
+            else if (activeSimulcastLayerNumber < sendTransceiver.getEncodingIndexForStreamId(id)) {
                 state = 'no source';
             }
             else {
@@ -13588,21 +13629,16 @@ class MultistreamConnection extends EventEmitter {
                     const rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
                         direction: 'recvonly',
                     });
-                    this.addMid(mediaType);
-                    const recvOnlyTransceiver = new ReceiveOnlyTransceiver(rtcRtpTransceiver, (mid) => {
-                        const ingressSignaler = this.streamSignalerManager.getIngressStreamSignaler(mid);
-                        if (!ingressSignaler) {
-                            return null;
-                        }
-                        return ingressSignaler.getReceiverId();
-                    });
-                    if (this.pc.getRemoteDescription()) {
-                        yield this.doLocalOfferAnswer();
-                    }
+                    const transceiverMid = this.midPredictor.getNextMid(mediaType);
+                    const ingressSignaler = createIngressStreamSignaler(this.options.streamSignalingMode, transceiverMid);
+                    const recvOnlyTransceiver = new ReceiveOnlyTransceiver(rtcRtpTransceiver, transceiverMid, ingressSignaler);
                     this.recvTransceivers.set(mediaType, [
                         ...(this.recvTransceivers.get(mediaType) || []),
                         recvOnlyTransceiver,
                     ]);
+                    if (this.pc.getRemoteDescription()) {
+                        yield this.doLocalOfferAnswer();
+                    }
                     createReceiveSlotResolve(recvOnlyTransceiver.receiveSlot);
                 }));
             });
@@ -13642,7 +13678,7 @@ class MultistreamConnection extends EventEmitter {
     createOffer() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.pc.getLocalDescription()) {
-                this.currentMid++;
+                this.midPredictor.allocateMidForDatachannel();
             }
             return new Promise((createOfferResolve) => {
                 this.offerAnswerQueue.push(() => __awaiter(this, void 0, void 0, function* () {
@@ -13668,7 +13704,6 @@ class MultistreamConnection extends EventEmitter {
     }
     setAnswer(answer) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isInitialAnswer = !this.pc.getRemoteDescription();
             const sdp = this.preProcessRemoteAnswer(answer);
             if (!this.setAnswerResolve) {
                 throw new Error(`Call to setAnswer without having previously called createOffer`);
@@ -13681,9 +13716,6 @@ class MultistreamConnection extends EventEmitter {
                 else {
                     logger.debug(`setAnswerResolve function was cleared between setAnswer and result of setRemoteDescription`);
                 }
-                if (isInitialAnswer && this.customCodecParameters.size > 0) {
-                    yield this.queueLocalOfferAnswer();
-                }
             }));
         });
     }
@@ -13721,43 +13753,17 @@ class MultistreamConnection extends EventEmitter {
         parsed.avMedia
             .filter((av) => av.direction === 'recvonly')
             .forEach((av) => {
-            const ingressSignaler = this.streamSignalerManager.getOrCreateIngressStreamSignaler(av.mid);
-            ingressSignaler.signalLocalStreams(av);
+            const transceiver = this.getRecvTransceiverByMidOrThrow(av.mid);
+            transceiver.signalLocalStreams(av);
         });
         parsed.avMedia
-            .filter((av) => av.direction === 'sendrecv')
+            .filter((av) => av.direction === 'sendrecv' || av.direction === 'inactive')
             .forEach((av) => {
-            const egressSignaler = this.streamSignalerManager.getOrCreateEgressStreamSignaler(av.mid);
-            const simulcastEnabled = hasSimulcast(av);
-            const rtxEnabled = av.type === 'video';
-            egressSignaler.signalStreams(simulcastEnabled, rtxEnabled, av);
-            if (av.type === 'video') {
-                [...av.codecs.values()]
-                    .filter((ci) => ci.name === 'H264')
-                    .forEach((ci) => {
-                    ci.fmtParams.set('max-mbps', `${defaultMaxVideoEncodeMbps}`);
-                    ci.fmtParams.set('max-fs', `${defaultMaxVideoEncodeFrameSize}`);
-                });
-            }
-            const mediaType = [...this.sendTransceivers.keys()].find((key) => { var _a; return ((_a = this.sendTransceivers.get(key)) === null || _a === void 0 ? void 0 : _a.mid) === av.mid; });
-            if (mediaType && this.customCodecParameters.has(mediaType)) {
-                [...av.codecs.values()]
-                    .filter((ci) => ci.name === (av.type === 'audio' ? 'opus' : 'H264'))
-                    .forEach((ci) => {
-                    var _a;
-                    (_a = this.customCodecParameters.get(mediaType)) === null || _a === void 0 ? void 0 : _a.forEach((value, param) => {
-                        if (value === null) {
-                            ci.fmtParams.delete(param);
-                        }
-                        else {
-                            ci.fmtParams.set(param, `${value}`);
-                        }
-                    });
-                });
-            }
+            const transceiver = this.getSendTransceiverByMidOrThrow(av.mid);
+            transceiver.signalStreams(av);
         });
         if (getBrowserDetails().name !== 'Firefox') {
-            setupBundle(parsed, this.options.bundlePolicy, this.midMap);
+            setupBundle(parsed, this.options.bundlePolicy, this.midPredictor.getMidMap());
         }
         return parsed.toString();
     }
@@ -13786,7 +13792,7 @@ class MultistreamConnection extends EventEmitter {
             }
         });
         if (getBrowserDetails().name === 'Firefox') {
-            setupBundle(parsed, this.options.bundlePolicy, this.midMap);
+            setupBundle(parsed, this.options.bundlePolicy, this.midPredictor.getMidMap());
             if (this.options.bundlePolicy === 'max-bundle') {
                 parsed.media.forEach((mline, index) => {
                     if (index > 0) {
@@ -13801,9 +13807,10 @@ class MultistreamConnection extends EventEmitter {
         var _a;
         const parsedAnswer = parse(answer);
         const parsedOffer = parse((_a = this.pc.getLocalDescription()) === null || _a === void 0 ? void 0 : _a.sdp);
-        matchMlinesInAnswer(parsedOffer, parsedAnswer, this.streamSignalerManager);
+        const recvTransceiversByMid = new Map([...this.recvTransceivers.values()].flat().map((t) => [t.mid, t]));
+        matchMlinesInAnswer(parsedOffer, parsedAnswer, recvTransceiversByMid);
         if (getBrowserDetails().name === 'Firefox') {
-            setupBundle(parsedAnswer, this.options.bundlePolicy, this.midMap);
+            setupBundle(parsedAnswer, this.options.bundlePolicy, this.midPredictor.getMidMap());
             if (this.options.bundlePolicy === 'max-bundle') {
                 const { ufrag, pwd } = parsedAnswer.media[0].iceInfo;
                 parsedAnswer.media.forEach((mline, index) => {
@@ -13823,6 +13830,20 @@ class MultistreamConnection extends EventEmitter {
         }
         return sendTransceiver;
     }
+    getSendTransceiverByMidOrThrow(mid) {
+        const transceiver = [...this.sendTransceivers.values()].find((t) => t.mid === mid);
+        if (!transceiver) {
+            throw new Error(`Unable to find send transceiver with mid ${mid}`);
+        }
+        return transceiver;
+    }
+    getRecvTransceiverByMidOrThrow(mid) {
+        const transceiver = [...this.recvTransceivers.values()].flat().find((t) => t.mid === mid);
+        if (!transceiver) {
+            throw new Error(`Unable to find recv transceiver with mid ${mid}`);
+        }
+        return transceiver;
+    }
     getPublishedTracks() {
         return [...this.sendTransceivers.values()]
             .map((transceiver) => transceiver.publishedTrack)
@@ -13830,11 +13851,8 @@ class MultistreamConnection extends EventEmitter {
     }
     setCodecParameters(mediaType, parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            const currentParams = this.customCodecParameters.get(mediaType) || new Map();
-            Object.entries(parameters).forEach(([param, value]) => {
-                currentParams.set(param, value);
-            });
-            this.customCodecParameters.set(mediaType, currentParams);
+            const transceiver = this.sendTransceivers.get(mediaType);
+            transceiver === null || transceiver === void 0 ? void 0 : transceiver.setCodecParameters(parameters);
             if (this.pc.getRemoteDescription()) {
                 yield this.queueLocalOfferAnswer();
             }
@@ -13842,11 +13860,8 @@ class MultistreamConnection extends EventEmitter {
     }
     deleteCodecParameters(mediaType, parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            const currentParams = this.customCodecParameters.get(mediaType) || new Map();
-            parameters.forEach((param) => {
-                currentParams.set(param, null);
-            });
-            this.customCodecParameters.set(mediaType, currentParams);
+            const transceiver = this.sendTransceivers.get(mediaType);
+            transceiver === null || transceiver === void 0 ? void 0 : transceiver.deleteCodecParameters(parameters);
             if (this.pc.getRemoteDescription()) {
                 yield this.queueLocalOfferAnswer();
             }
@@ -13890,32 +13905,34 @@ class MultistreamConnection extends EventEmitter {
             this.options = Object.assign(Object.assign({}, this.options), userOptions);
         }
         logger.info(`Renewing multistream connection with options ${JSON.stringify(this.options)}`);
-        this.clearMids();
+        this.midPredictor.reset();
         this.initializePeerConnection();
-        this.streamSignalerManager = new StreamSignalerManager(this.options.streamSignalingMode);
         const mainSceneId = generateSceneId();
         const slidesSceneId = generateSceneId();
         this.sendTransceivers.forEach((transceiver, mediaType) => {
             var _a;
             const mediaContent = getMediaContent(mediaType);
             const sceneId = mediaContent === MediaContent.Main ? mainSceneId : slidesSceneId;
-            this.addMid(mediaType);
+            const mid = this.midPredictor.getNextMid(mediaType);
             transceiver.replaceTransceiver(this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
                 direction: 'sendrecv',
                 sendEncodings: getMediaFamily(mediaType) === MediaFamily.Video
                     ? this.getVideoEncodingOptions(mediaContent)
                     : undefined,
             }));
+            transceiver.mid = mid;
             transceiver.csi = generateCsi(getMediaFamily(mediaType), sceneId);
+            transceiver.resetStreamSignaler();
             (_a = this.jmpSessions.get(mediaType)) === null || _a === void 0 ? void 0 : _a.close();
             this.createJmpSession(mediaType);
         });
         this.recvTransceivers.forEach((transceivers, mediaType) => {
             transceivers.forEach((t) => {
-                this.addMid(mediaType);
+                const mid = this.midPredictor.getNextMid(mediaType);
                 t.replaceTransceiver(this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
                     direction: 'recvonly',
                 }));
+                t.mid = mid;
             });
         });
     }
@@ -13964,10 +13981,7 @@ class MultistreamConnection extends EventEmitter {
                             statsToModify.mid = (_a = transceiver.receiveSlot.id) === null || _a === void 0 ? void 0 : _a.mid;
                             statsToModify.csi = transceiver.receiveSlot.currentRxCsi;
                             statsToModify.mediaType = mediaType;
-                            const signaler = this.streamSignalerManager.getIngressStreamSignaler(statsToModify.mid);
-                            if (signaler) {
-                                Object.assign(statsToModify, signaler.getReceiverId());
-                            }
+                            Object.assign(statsToModify, transceiver.receiverId);
                             stats.set(receiverStats.id, statsToModify);
                         }
                     });