@webex/web-client-media-engine 3.35.0 → 3.35.2

package/dist/cjs/index.js

@@ -7158,6 +7158,29 @@ function isValidActiveSpeakerNotificationMsg(msg) {
     const maybeActiveSpeakerNotificationMsg = msg;
     return Boolean(maybeActiveSpeakerNotificationMsg.seqNum && maybeActiveSpeakerNotificationMsg.csis);
 }
+function isValidAV1Codec(msg) {
+    if (typeof msg !== 'object' || msg === null) {
+        return false;
+    }
+    const maybeAV1Codec = msg;
+    return (maybeAV1Codec.levelIdx >= 0 &&
+        maybeAV1Codec.tier >= 0 &&
+        Boolean(maybeAV1Codec.maxWidth) &&
+        Boolean(maybeAV1Codec.maxHeight) &&
+        Boolean(maybeAV1Codec.maxPicSize) &&
+        Boolean(maybeAV1Codec.maxDecodeRate));
+}
+function areAV1CodecsEqual(left, right) {
+    if (left === undefined || right === undefined) {
+        return left === right;
+    }
+    return (left.levelIdx === right.levelIdx &&
+        left.tier === right.tier &&
+        left.maxWidth === right.maxWidth &&
+        left.maxHeight === right.maxHeight &&
+        left.maxPicSize === right.maxPicSize &&
+        left.maxDecodeRate === right.maxDecodeRate);
+}
 
 class H264Codec {
     constructor(maxFs, maxFps, maxMbps, maxWidth, maxHeight) {
@@ -7168,6 +7191,13 @@ class H264Codec {
         this.maxHeight = maxHeight;
     }
 }
+function isValidH264Codec(msg) {
+    if (typeof msg !== 'object' || msg === null) {
+        return false;
+    }
+    const maybeH264Codec = msg;
+    return Boolean(maybeH264Codec.maxFs && maybeH264Codec.maxFps && maybeH264Codec.maxMbps);
+}
 function areH264CodecsEqual(left, right) {
     if (left === undefined || right === undefined) {
         return left === right;
@@ -7180,13 +7210,31 @@ function areH264CodecsEqual(left, right) {
 }
 
 class CodecInfo$1 {
-    constructor(payloadType, h264) {
+    constructor(payloadType, codec) {
         this.payloadType = payloadType;
-        this.h264 = h264;
+        if (isValidAV1Codec(codec))
+            this.av1 = codec;
+        if (isValidH264Codec(codec))
+            this.h264 = codec;
+    }
+    static fromH264(payloadType, h264) {
+        return new CodecInfo$1(payloadType, h264);
+    }
+    static fromAv1(payloadType, av1) {
+        return new CodecInfo$1(payloadType, av1);
     }
 }
 function areCodecInfosEqual(left, right) {
-    return left.payloadType === right.payloadType && areH264CodecsEqual(left.h264, right.h264);
+    if (left.payloadType !== right.payloadType) {
+        return false;
+    }
+    if (isValidH264Codec(left.h264) && isValidH264Codec(right.h264)) {
+        return areH264CodecsEqual(left.h264, right.h264);
+    }
+    if (isValidAV1Codec(left.av1) && isValidAV1Codec(right.av1)) {
+        return areAV1CodecsEqual(left.av1, right.av1);
+    }
+    return false;
 }
 
 var JmpMsgType;
@@ -16167,6 +16215,9 @@ SCTP Max Message Size: ${maxMessageSize}`);
             csi: sendTransceiver.csi,
         }));
     }
+    static getEncodedTransformId(mediaType, mid) {
+        return `INBOUND-${mediaType}-${mid}`;
+    }
     createReceiveTransceiver(mediaType) {
         const rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
             direction: 'recvonly',
@@ -16181,20 +16232,19 @@ SCTP Max Message Size: ${maxMessageSize}`);
             munger,
         });
         if (doAudioLevelMonitoring) {
-            const encodedTransformId = `INBOUND-${mediaType}-${mid}`;
             try {
-                this.setupEncodedTransform(rtcRtpTransceiver.receiver, encodedTransformId, EncodedTransformType.AudioLevelMonitor);
+                this.setupEncodedTransform(rtcRtpTransceiver.receiver, MultistreamConnection.getEncodedTransformId(mediaType, recvOnlyTransceiver.mid), EncodedTransformType.AudioLevelMonitor);
                 recvOnlyTransceiver.setEncodedStreamMetadataCallback(() => __awaiter(this, void 0, void 0, function* () {
                     return getWorkerManager().sendRequestToWorker({
                         type: MainMsgType.GetMetadata,
                         mediaType,
-                        encodedTransformId,
+                        encodedTransformId: MultistreamConnection.getEncodedTransformId(mediaType, recvOnlyTransceiver.mid),
                         multistreamConnectionId: this.id,
                     });
                 }));
             }
             catch (e) {
-                logger.warn(`Failed to setup encoded transform for ${encodedTransformId} audio level monitoring: ${e}`);
+                logger.warn(`Failed to setup encoded transform for audio level monitoring of mid=${mid}: ${e}`);
             }
         }
         if (getMediaFamily(mediaType) === exports.MediaFamily.Video) {
@@ -16577,6 +16627,12 @@ SCTP Max Message Size: ${maxMessageSize}`);
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             (_a = this.pc) === null || _a === void 0 ? void 0 : _a.close();
+            if (getWorkerManager().getWorker()) {
+                yield getWorkerManager().sendRequestToWorker({
+                    type: MainMsgType.ClearMetadata,
+                    multistreamConnectionId: this.id,
+                });
+            }
             try {
                 if (userOptions) {
                     this.options = Object.assign(Object.assign({}, this.options), (yield userOptions));
@@ -16610,10 +16666,14 @@ SCTP Max Message Size: ${maxMessageSize}`);
             this.recvTransceivers.forEach((transceivers, mediaType) => {
                 transceivers.forEach((t) => {
                     const mid = this.midPredictor.getNextMid(mediaType);
-                    t.replaceTransceiver(this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
+                    const rtcRtpTransceiver = this.pc.addTransceiver(toMediaStreamTrackKind(mediaType), {
                         direction: 'recvonly',
-                    }));
+                    });
+                    t.replaceTransceiver(rtcRtpTransceiver);
                     t.mid = mid;
+                    if (this.options.enableInboundAudioLevelMonitoring && mediaType === exports.MediaType.AudioMain) {
+                        this.setupEncodedTransform(rtcRtpTransceiver.receiver, MultistreamConnection.getEncodedTransformId(mediaType, mid), EncodedTransformType.AudioLevelMonitor);
+                    }
                 });
             });
         });