@webex/web-client-media-engine 3.36.1 → 3.37.1

package/dist/esm/index.js

@@ -8206,6 +8206,24 @@ function getRecommendedMaxBitrateForFrameSize(requestedMaxFs) {
         .sort((a, b) => b - a)
         .find((h) => requestedMaxFs >= h);
     return maxFrameSizeToMaxBitrateMap.get(expectedHeight);
+}
+function setCodecParameters(allCodecParameters, codecMimeType, newParameters) {
+    if (!allCodecParameters.has(codecMimeType)) {
+        allCodecParameters.set(codecMimeType, {});
+    }
+    const currentParameters = allCodecParameters.get(codecMimeType);
+    Object.entries(newParameters).forEach(([param, value]) => {
+        currentParameters[param] = value;
+    });
+}
+function markCodecParametersForDeletion(allCodecParameters, codecMimeTypeToUpdate, codecParameters) {
+    if (!allCodecParameters.has(codecMimeTypeToUpdate)) {
+        allCodecParameters.set(codecMimeTypeToUpdate, {});
+    }
+    const currentParameters = allCodecParameters.get(codecMimeTypeToUpdate);
+    codecParameters.forEach((param) => {
+        currentParameters[param] = undefined;
+    });
 }
 
 /******************************************************************************
@@ -10439,16 +10457,17 @@ function addVlaExtension(mediaDescription) {
         mediaDescription.addExtension({ uri: vlaExtensionUri });
     }
 }
-function applyFormatParameters(mediaDescription, codecs, paramsMap) {
-    paramsMap.forEach((value, param) => {
+function setFormatParameters(mediaDescription, codecMimeType, paramsMap) {
+    const codecName = codecMimeType.split('/')[1].toLowerCase();
+    Object.entries(paramsMap).forEach(([param, value]) => {
         [...mediaDescription.codecs.values()]
-            .filter((ci) => ci.name && codecs.includes(ci.name))
+            .filter((ci) => ci.name && codecName === ci.name.toLowerCase())
             .forEach((ci) => {
-            if (value === null) {
+            if (value === undefined) {
                 ci.fmtParams.delete(param);
             }
             else {
-                ci.fmtParams.set(param, `${value}`);
+                ci.fmtParams.set(param, value);
             }
         });
     });
@@ -10563,7 +10582,9 @@ class EgressSdpMunger {
         if (options.simulcastEnabled) {
             mediaDescription.addLine(new SsrcGroupLine('SIM', this.streamIds.map((streamId) => streamId.ssrc)));
         }
-        applyFormatParameters(mediaDescription, ['H264', 'opus'], this.customCodecParameters);
+        this.customCodecParameters.forEach((codecParams, codecMimeType) => {
+            setFormatParameters(mediaDescription, codecMimeType, codecParams);
+        });
         if (options.twccDisabled) {
             disableTwcc(mediaDescription);
         }
@@ -10593,7 +10614,9 @@ class EgressSdpMunger {
                 ci.fmtParams.set('usedtx', mungeOptions.dtxDisabled ? '0' : '1');
             });
         }
-        applyFormatParameters(mediaDescription, ['H264', 'opus'], this.customCodecParameters);
+        this.customCodecParameters.forEach((codecParams, codecMimeType) => {
+            setFormatParameters(mediaDescription, codecMimeType, codecParams);
+        });
     }
     getSenderIds() {
         return this.streamIds;
@@ -10601,15 +10624,11 @@ class EgressSdpMunger {
     getEncodingIndexForStreamId(streamId) {
         return this.streamIds.findIndex((currStreamId) => areStreamIdsEqual(currStreamId, streamId));
     }
-    setCodecParameters(parameters) {
-        Object.entries(parameters).forEach(([param, value]) => {
-            this.customCodecParameters.set(param, value);
-        });
+    setCustomCodecParameters(codecMimeType, parameters) {
+        setCodecParameters(this.customCodecParameters, codecMimeType, parameters);
     }
-    deleteCodecParameters(parameters) {
-        parameters.forEach((param) => {
-            this.customCodecParameters.set(param, null);
-        });
+    markCustomCodecParametersForDeletion(codecMimeType, parameters) {
+        markCodecParametersForDeletion(this.customCodecParameters, codecMimeType, parameters);
     }
 }
 
@@ -11095,7 +11114,6 @@ class EventEmitter$2 extends events$1.exports.EventEmitter {
 class IngressSdpMunger {
     constructor() {
         this.customCodecParameters = new Map();
-        this.customRtxCodecParameters = new Map();
         this.ssrc = generateSsrc();
     }
     getReceiverId() {
@@ -11107,8 +11125,9 @@ class IngressSdpMunger {
             logErrorAndThrow(WcmeErrorType.SDP_MUNGE_MISSING_CODECS, `No codecs present in m-line with MID ${mediaDescription.mid} after filtering.`);
         }
         removeMidRidExtensions(mediaDescription);
-        applyFormatParameters(mediaDescription, ['H264', 'opus'], this.customCodecParameters);
-        applyFormatParameters(mediaDescription, ['rtx'], this.customRtxCodecParameters);
+        this.customCodecParameters.forEach((codecParams, codecMimeType) => {
+            setFormatParameters(mediaDescription, codecMimeType, codecParams);
+        });
         if (options.twccDisabled) {
             disableTwcc(mediaDescription);
         }
@@ -11129,17 +11148,16 @@ class IngressSdpMunger {
         if (retainCandidatesByTransportType(mediaDescription, ['udp', 'tcp'])) {
             logger.log(`Some unsupported remote candidates have been removed from mid ${mediaDescription.mid}`);
         }
-        applyFormatParameters(mediaDescription, ['rtx'], this.customRtxCodecParameters);
+        const rtxParams = this.customCodecParameters.get(MediaCodecMimeType.RTX);
+        if (rtxParams) {
+            setFormatParameters(mediaDescription, MediaCodecMimeType.RTX, rtxParams);
+        }
     }
-    setCodecParameters(parameters) {
-        Object.entries(parameters).forEach(([param, value]) => {
-            this.customCodecParameters.set(param, value);
-        });
+    setCustomCodecParameters(codecMimeType, parameters) {
+        setCodecParameters(this.customCodecParameters, codecMimeType, parameters);
     }
-    setRtxCodecParameters(parameters) {
-        Object.entries(parameters).forEach(([param, value]) => {
-            this.customRtxCodecParameters.set(param, value);
-        });
+    markCustomCodecParametersForDeletion(codecMimeType, parameters) {
+        markCodecParametersForDeletion(this.customCodecParameters, codecMimeType, parameters);
     }
     reset() {
         this.ssrc = generateSsrc();
@@ -11452,11 +11470,8 @@ class ReceiveOnlyTransceiver extends Transceiver {
             this.metadata.lastActiveSpeakerUpdateTimestamp = getCurrentTimestamp();
         }
     }
-    setCodecParameters(parameters) {
-        this.munger.setCodecParameters(parameters);
-    }
-    setRtxCodecParameters(parameters) {
-        this.munger.setRtxCodecParameters(parameters);
+    setCustomCodecParameters(codecMimeType, parameters) {
+        this.munger.setCustomCodecParameters(codecMimeType, parameters);
     }
 }
 ReceiveOnlyTransceiver.rid = '1';
@@ -15432,12 +15447,12 @@ class SendOnlyTransceiver extends Transceiver {
     resetSdpMunger() {
         this.munger.reset();
     }
-    setCodecParameters(parameters) {
-        this.munger.setCodecParameters(parameters);
+    setCustomCodecParameters(codecMimeType, codecParams) {
+        this.munger.setCustomCodecParameters(codecMimeType, codecParams);
         this.negotiationNeeded.emit(OfferAnswerType.LocalOnly);
     }
-    deleteCodecParameters(parameters) {
-        this.munger.deleteCodecParameters(parameters);
+    markCustomCodecParametersForDeletion(codecMimeType, parameters) {
+        this.munger.markCustomCodecParametersForDeletion(codecMimeType, parameters);
         this.negotiationNeeded.emit(OfferAnswerType.LocalOnly);
     }
     setSourceStateOverride(state) {
@@ -15498,12 +15513,26 @@ class SendSlot {
     }
     setCodecParameters(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.sendTransceiver.setCodecParameters(parameters);
+            [MediaCodecMimeType.H264, MediaCodecMimeType.OPUS].forEach((codecMimeType) => {
+                this.setCustomCodecParameters(codecMimeType, parameters);
+            });
         });
     }
     deleteCodecParameters(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.sendTransceiver.deleteCodecParameters(parameters);
+            [MediaCodecMimeType.H264, MediaCodecMimeType.OPUS].forEach((codecMimeType) => {
+                this.markCustomCodecParametersForDeletion(codecMimeType, parameters);
+            });
+        });
+    }
+    setCustomCodecParameters(codecMimeType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sendTransceiver.setCustomCodecParameters(codecMimeType, parameters);
+        });
+    }
+    markCustomCodecParametersForDeletion(codecMimeType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sendTransceiver.markCustomCodecParametersForDeletion(codecMimeType, parameters);
         });
     }
     setSourceStateOverride(state) {
@@ -15697,7 +15726,7 @@ function getWorkerManager() {
     return WorkerManager.workerManagerInstance;
 }
 
-function toMediaStreamTrackKind(mediaType) {
+function mediaTypeToTrackKind(mediaType) {
     return [MediaType.VideoMain, MediaType.VideoSlides].includes(mediaType)
         ? MediaStreamTrackKind.Video
         : MediaStreamTrackKind.Audio;
@@ -15767,9 +15796,10 @@ class MultistreamConnection extends EventEmitter$2 {
         const slidesSceneId = generateSceneId();
         const videoMainEncodingOptions = this.getVideoEncodingOptions(MediaContent.Main);
         const videoSlidesEncodingOptions = this.getVideoEncodingOptions(MediaContent.Slides);
-        this.createSendTransceiver(MediaType.VideoMain, mainSceneId, videoMainEncodingOptions);
+        const sendVideoCodecParams = this.getCustomSendVideoCodecParams();
+        this.createSendTransceiver(MediaType.VideoMain, mainSceneId, videoMainEncodingOptions, sendVideoCodecParams);
         this.createSendTransceiver(MediaType.AudioMain, mainSceneId);
-        this.createSendTransceiver(MediaType.VideoSlides, slidesSceneId, videoSlidesEncodingOptions);
+        this.createSendTransceiver(MediaType.VideoSlides, slidesSceneId, videoSlidesEncodingOptions, sendVideoCodecParams);
         this.createSendTransceiver(MediaType.AudioSlides, slidesSceneId);
     }
     startWorkerIfNeeded() {
@@ -15847,10 +15877,29 @@ class MultistreamConnection extends EventEmitter$2 {
             ]
             : [{ active: false }];
     }
-    createSendTransceiver(mediaType, sceneId, sendEncodingsOptions) {
+    getCustomSendVideoCodecParams() {
+        return {
+            [MediaCodecMimeType.H264]: {
+                'x-google-start-bitrate': `${this.options.preferredStartingBitrateKbps}`,
+                'max-mbps': `${defaultMaxVideoEncodeMbps}`,
+                'max-fs': `${defaultMaxVideoEncodeFrameSize}`,
+            },
+        };
+    }
+    getCustomReceiveVideoCodecParams(mediaType) {
+        return {
+            [MediaCodecMimeType.H264]: {
+                'sps-pps-idr-in-keyframe': '1',
+            },
+            [MediaCodecMimeType.RTX]: {
+                'rtx-time': mediaType === MediaType.VideoMain ? defaultVideoMainRtxTime : defaultVideoSlidesRtxTime,
+            },
+        };
+    }
+    createSendTransceiver(mediaType, sceneId, sendEncodingsOptions, codecParams) {
         let rtcRtpTransceiver;
         try {
-            rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
+            rtcRtpTransceiver = this.pc.addTransceiver(mediaTypeToTrackKind(mediaType), {
                 direction: 'sendrecv',
                 sendEncodings: sendEncodingsOptions,
             });
@@ -15869,14 +15918,12 @@ class MultistreamConnection extends EventEmitter$2 {
             munger,
             csi,
         });
-        let codecParameters = {
-            'x-google-start-bitrate': `${this.options.preferredStartingBitrateKbps}`,
-        };
         if (getMediaFamily(mediaType) === MediaFamily.Video) {
             transceiver.rtxEnabled = true;
-            codecParameters = Object.assign(Object.assign({}, codecParameters), { 'max-mbps': `${defaultMaxVideoEncodeMbps}`, 'max-fs': `${defaultMaxVideoEncodeFrameSize}` });
         }
-        transceiver.setCodecParameters(codecParameters);
+        Object.entries(codecParams !== null && codecParams !== void 0 ? codecParams : {}).forEach(([codec, params]) => {
+            transceiver.setCustomCodecParameters(codec, params);
+        });
         transceiver.twccDisabled =
             getMediaFamily(mediaType) === MediaFamily.Audio ? this.options.disableAudioTwcc : false;
         transceiver.dtxDisabled = mediaType !== MediaType.AudioMain || this.options.disableAudioMainDtx;
@@ -16177,8 +16224,8 @@ SCTP Max Message Size: ${maxMessageSize}`);
     static getEncodedTransformId(mediaType, mid) {
         return `INBOUND-${mediaType}-${mid}`;
     }
-    createReceiveTransceiver(mediaType) {
-        const rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
+    createReceiveTransceiver(mediaType, codecParams) {
+        const rtcRtpTransceiver = this.pc.addTransceiver(mediaTypeToTrackKind(mediaType), {
             direction: 'recvonly',
         });
         const mid = this.midPredictor.getNextMid(mediaType);
@@ -16206,14 +16253,9 @@ SCTP Max Message Size: ${maxMessageSize}`);
                 logger.warn(`Failed to setup encoded transform for audio level monitoring of mid=${mid}: ${e}`);
             }
         }
-        if (getMediaFamily(mediaType) === MediaFamily.Video) {
-            recvOnlyTransceiver.setCodecParameters({
-                'sps-pps-idr-in-keyframe': '1',
-            });
-            recvOnlyTransceiver.setRtxCodecParameters({
-                'rtx-time': mediaType === MediaType.VideoMain ? defaultVideoMainRtxTime : defaultVideoSlidesRtxTime,
-            });
-        }
+        Object.entries(codecParams !== null && codecParams !== void 0 ? codecParams : {}).forEach(([codec, params]) => {
+            recvOnlyTransceiver.setCustomCodecParameters(codec, params);
+        });
         recvOnlyTransceiver.twccDisabled =
             getMediaFamily(mediaType) === MediaFamily.Audio ? this.options.disableAudioTwcc : false;
         this.recvTransceivers.set(mediaType, [
@@ -16232,8 +16274,11 @@ SCTP Max Message Size: ${maxMessageSize}`);
             return new Promise((createReceiveSlotsResolve) => {
                 this.offerAnswerQueue.push(() => __awaiter(this, void 0, void 0, function* () {
                     const createdReceiveOnlyTransceivers = [];
+                    const codecParams = mediaTypeToTrackKind(mediaType) === MediaStreamTrackKind.Video
+                        ? this.getCustomReceiveVideoCodecParams(mediaType)
+                        : undefined;
                     for (let i = 0; i < count; i++) {
-                        const recvOnlyTransceiver = this.createReceiveTransceiver(mediaType);
+                        const recvOnlyTransceiver = this.createReceiveTransceiver(mediaType, codecParams);
                         createdReceiveOnlyTransceivers.push(recvOnlyTransceiver);
                     }
                     if (this.pc.getRemoteDescription()) {
@@ -16610,7 +16655,7 @@ SCTP Max Message Size: ${maxMessageSize}`);
                 const mediaContent = getMediaContent(mediaType);
                 const sceneId = mediaContent === MediaContent.Main ? mainSceneId : slidesSceneId;
                 const mid = this.midPredictor.getNextMid(mediaType);
-                transceiver.replaceTransceiver(this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
+                transceiver.replaceTransceiver(this.pc.addTransceiver(mediaTypeToTrackKind(mediaType), {
                     direction: 'sendrecv',
                     sendEncodings: getMediaFamily(mediaType) === MediaFamily.Video
                         ? this.getVideoEncodingOptions(mediaContent)
@@ -16625,7 +16670,7 @@ SCTP Max Message Size: ${maxMessageSize}`);
             this.recvTransceivers.forEach((transceivers, mediaType) => {
                 transceivers.forEach((t) => {
                     const mid = this.midPredictor.getNextMid(mediaType);
-                    const rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
+                    const rtcRtpTransceiver = this.pc.addTransceiver(mediaTypeToTrackKind(mediaType), {
                         direction: 'recvonly',
                     });
                     t.replaceTransceiver(rtcRtpTransceiver);