@webex/web-client-media-engine 3.34.5 → 3.35.1

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;
@@ -7740,6 +7788,7 @@ exports.WcmeErrorType = void 0;
     WcmeErrorType["SET_SOURCE_STATE_OVERRIDE_FAILED"] = "SET_SOURCE_STATE_OVERRIDE_FAILED";
     WcmeErrorType["DATA_CHANNEL_SEND_FAILED"] = "DATA_CHANNEL_SEND_FAILED";
     WcmeErrorType["RENEW_PEER_CONNECTION_FAILED"] = "RENEW_PEER_CONNECTION_FAILED";
+    WcmeErrorType["UNSUPPORTED_CONFIG"] = "UNSUPPORTED_CONFIG";
 })(exports.WcmeErrorType || (exports.WcmeErrorType = {}));
 class WcmeError {
     constructor(type, message = '') {
@@ -10099,6 +10148,12 @@ class BrowserInfo {
 }
 BrowserInfo.browser = Bowser.getParser(window.navigator.userAgent);
 
+class CpuInfo {
+    static getNumLogicalCores() {
+        return navigator.hardwareConcurrency;
+    }
+}
+
 var SystemInfoEvents;
 (function (SystemInfoEvents) {
     SystemInfoEvents["CpuPressureStateChange"] = "cpu-pressure-state-change";
@@ -10136,7 +10191,58 @@ var CapabilityState;
     CapabilityState["NOT_CAPABLE"] = "not capable";
     CapabilityState["CAPABLE"] = "capable";
     CapabilityState["UNKNOWN"] = "unknown";
-})(CapabilityState || (CapabilityState = {}));
+})(CapabilityState || (CapabilityState = {}));
+class WebCapabilities {
+    static isCapableOfBackgroundNoiseRemoval() {
+        const numCores = CpuInfo.getNumLogicalCores();
+        if (numCores === undefined) {
+            return CapabilityState.UNKNOWN;
+        }
+        if (numCores < 2) {
+            return CapabilityState.NOT_CAPABLE;
+        }
+        return CapabilityState.CAPABLE;
+    }
+    static isCapableOfVirtualBackground() {
+        const numCores = CpuInfo.getNumLogicalCores();
+        if (numCores === undefined) {
+            return CapabilityState.UNKNOWN;
+        }
+        if (numCores < 2) {
+            return CapabilityState.NOT_CAPABLE;
+        }
+        return CapabilityState.CAPABLE;
+    }
+    static isCapableOfReceiving1080pVideo() {
+        const numCores = CpuInfo.getNumLogicalCores();
+        if (numCores === undefined) {
+            return CapabilityState.UNKNOWN;
+        }
+        if (numCores < 2) {
+            return CapabilityState.NOT_CAPABLE;
+        }
+        return CapabilityState.CAPABLE;
+    }
+    static isCapableOfSending1080pVideo() {
+        const numCores = CpuInfo.getNumLogicalCores();
+        if (numCores === undefined) {
+            return CapabilityState.UNKNOWN;
+        }
+        if (numCores < 8) {
+            return CapabilityState.NOT_CAPABLE;
+        }
+        return CapabilityState.CAPABLE;
+    }
+    static supportsEncodedStreamTransforms() {
+        return window.RTCRtpScriptTransform &&
+            window.RTCRtpSender &&
+            'transform' in RTCRtpSender.prototype &&
+            window.RTCRtpReceiver &&
+            'transform' in RTCRtpReceiver.prototype
+            ? CapabilityState.CAPABLE
+            : CapabilityState.NOT_CAPABLE;
+    }
+}
 
 const simulcastMaxFrameSizes = {
     0: '240',
@@ -11060,6 +11166,21 @@ class HomerMsg {
     }
 }
 
+var EncodedTransformType;
+(function (EncodedTransformType) {
+    EncodedTransformType["AudioLevelMonitor"] = "audio-level-monitor";
+})(EncodedTransformType || (EncodedTransformType = {}));
+var MainMsgType;
+(function (MainMsgType) {
+    MainMsgType["GetMetadata"] = "get-metadata";
+    MainMsgType["ClearMetadata"] = "clear-metadata";
+})(MainMsgType || (MainMsgType = {}));
+var WorkerMsgType;
+(function (WorkerMsgType) {
+    WorkerMsgType["Response"] = "response";
+    WorkerMsgType["Log"] = "log";
+})(WorkerMsgType || (WorkerMsgType = {}));
+
 class MidPredictor {
     constructor() {
         this.currentMid = 0;
@@ -11240,6 +11361,7 @@ class ReceiveOnlyTransceiver extends Transceiver {
     constructor(config) {
         super(config);
         this.metadata = { isActiveSpeaker: false };
+        this.getEncodedStreamMetadataCallback = () => Promise.resolve(undefined);
         this.munger = config.munger;
         this._receiveSlot = new ReceiveSlot(() => {
             if (!this._rtcRtpTransceiver.mid) {
@@ -11248,6 +11370,9 @@ class ReceiveOnlyTransceiver extends Transceiver {
             return this.munger.getReceiverId();
         }, this._rtcRtpTransceiver.receiver.track);
     }
+    setEncodedStreamMetadataCallback(callback) {
+        this.getEncodedStreamMetadataCallback = callback;
+    }
     replaceTransceiver(newRtcRtpTransceiver) {
         super.replaceTransceiver(newRtcRtpTransceiver);
         this._receiveSlot._replaceTrack(newRtcRtpTransceiver.receiver.track);
@@ -11262,7 +11387,10 @@ class ReceiveOnlyTransceiver extends Transceiver {
     getStats() {
         return __awaiter(this, void 0, void 0, function* () {
             const statsMap = new Map();
-            const statsReport = yield this.receiver.getStats();
+            const [statsReport, encodedStreamMetadata] = yield Promise.all([
+                this.receiver.getStats(),
+                this.getEncodedStreamMetadataCallback(),
+            ]);
             statsReport.forEach((stats, key) => {
                 if (stats.type === 'inbound-rtp') {
                     stats.mid = this.mid;
@@ -11276,6 +11404,10 @@ class ReceiveOnlyTransceiver extends Transceiver {
                     stats.lastRequestedUpdateTimestamp = this.metadata.lastRequestedUpdateTimestamp;
                     stats.isActiveSpeaker = this.metadata.isActiveSpeaker;
                     stats.lastActiveSpeakerUpdateTimestamp = this.metadata.lastActiveSpeakerUpdateTimestamp;
+                    stats.maxAudioLevelFromRtpHeader =
+                        encodedStreamMetadata && 'maxAudioLevel' in encodedStreamMetadata
+                            ? encodedStreamMetadata.maxAudioLevel
+                            : undefined;
                     Object.assign(stats, this.receiverId);
                 }
                 statsMap.set(key, stats);
@@ -15458,6 +15590,154 @@ const organizeTransceiverStats = (sendTransceivers, recvTransceivers, peerConnec
     return result;
 });
 
+var WorkerClass = null;
+
+try {
+    var WorkerThreads =
+        typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') ||
+        typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') ||
+        typeof require === 'function' && require('worker_threads');
+    WorkerClass = WorkerThreads.Worker;
+} catch(e) {} // eslint-disable-line
+
+function decodeBase64$1(base64, enableUnicode) {
+    return Buffer.from(base64, 'base64').toString(enableUnicode ? 'utf16' : 'utf8');
+}
+
+function createBase64WorkerFactory$2(base64, sourcemapArg, enableUnicodeArg) {
+    var sourcemap = sourcemapArg === undefined ? null : sourcemapArg;
+    var enableUnicode = enableUnicodeArg === undefined ? false : enableUnicodeArg;
+    var source = decodeBase64$1(base64, enableUnicode);
+    var start = source.indexOf('\n', 10) + 1;
+    var body = source.substring(start) + (sourcemap ? '\/\/# sourceMappingURL=' + sourcemap : '');
+    return function WorkerFactory(options) {
+        return new WorkerClass(body, Object.assign({}, options, { eval: true }));
+    };
+}
+
+function decodeBase64(base64, enableUnicode) {
+    var binaryString = atob(base64);
+    if (enableUnicode) {
+        var binaryView = new Uint8Array(binaryString.length);
+        for (var i = 0, n = binaryString.length; i < n; ++i) {
+            binaryView[i] = binaryString.charCodeAt(i);
+        }
+        const decoder = new TextDecoder("utf-16le");
+        return decoder.decode(new Uint16Array(binaryView.buffer));
+    }
+    return binaryString;
+}
+
+function createURL(base64, sourcemapArg, enableUnicodeArg) {
+    var sourcemap = sourcemapArg === undefined ? null : sourcemapArg;
+    var enableUnicode = enableUnicodeArg === undefined ? false : enableUnicodeArg;
+    var source = decodeBase64(base64, enableUnicode);
+    var start = source.indexOf('\n', 10) + 1;
+    var body = source.substring(start) + (sourcemap ? '\/\/# sourceMappingURL=' + sourcemap : '');
+    var blob = new Blob([body], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+
+function createBase64WorkerFactory$1(base64, sourcemapArg, enableUnicodeArg) {
+    var url;
+    return function WorkerFactory(options) {
+        url = url || createURL(base64, sourcemapArg, enableUnicodeArg);
+        return new Worker(url, options);
+    };
+}
+
+var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+
+function isNodeJS() {
+    return kIsNodeJS;
+}
+
+function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
+    if (isNodeJS()) {
+        return createBase64WorkerFactory$2(base64, sourcemapArg, enableUnicodeArg);
+    }
+    return createBase64WorkerFactory$1(base64, sourcemapArg, enableUnicodeArg);
+}
+
+var WorkerFactory = /*#__PURE__*/createBase64WorkerFactory('/* rollup-plugin-web-worker-loader */
(function () {
    'use strict';

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    var logger = {exports: {}};

    /*!
     * js-logger - http://github.com/jonnyreeves/js-logger
     * Jonny Reeves, http://jonnyreeves.co.uk/
     * js-logger may be freely distributed under the MIT license.
     */

    (function (module) {
    (function (global) {

    	// Top level module for the global, static logger instance.
    	var Logger = { };

    	// For those that are at home that are keeping score.
    	Logger.VERSION = "1.6.1";

    	// Function which handles all incoming log messages.
    	var logHandler;

    	// Map of ContextualLogger instances by name; used by Logger.get() to return the same named instance.
    	var contextualLoggersByNameMap = {};

    	// Polyfill for ES5's Function.bind.
    	var bind = function(scope, func) {
    		return function() {
    			return func.apply(scope, arguments);
    		};
    	};

    	// Super exciting object merger-matron 9000 adding another 100 bytes to your download.
    	var merge = function () {
    		var args = arguments, target = args[0], key, i;
    		for (i = 1; i < args.length; i++) {
    			for (key in args[i]) {
    				if (!(key in target) && args[i].hasOwnProperty(key)) {
    					target[key] = args[i][key];
    				}
    			}
    		}
    		return target;
    	};

    	// Helper to define a logging level object; helps with optimisation.
    	var defineLogLevel = function(value, name) {
    		return { value: value, name: name };
    	};

    	// Predefined logging levels.
    	Logger.TRACE = defineLogLevel(1, 'TRACE');
    	Logger.DEBUG = defineLogLevel(2, 'DEBUG');
    	Logger.INFO = defineLogLevel(3, 'INFO');
    	Logger.TIME = defineLogLevel(4, 'TIME');
    	Logger.WARN = defineLogLevel(5, 'WARN');
    	Logger.ERROR = defineLogLevel(8, 'ERROR');
    	Logger.OFF = defineLogLevel(99, 'OFF');

    	// Inner class which performs the bulk of the work; ContextualLogger instances can be configured independently
    	// of each other.
    	var ContextualLogger = function(defaultContext) {
    		this.context = defaultContext;
    		this.setLevel(defaultContext.filterLevel);
    		this.log = this.info;  // Convenience alias.
    	};

    	ContextualLogger.prototype = {
    		// Changes the current logging level for the logging instance.
    		setLevel: function (newLevel) {
    			// Ensure the supplied Level object looks valid.
    			if (newLevel && "value" in newLevel) {
    				this.context.filterLevel = newLevel;
    			}
    		},
    		
    		// Gets the current logging level for the logging instance
    		getLevel: function () {
    			return this.context.filterLevel;
    		},

    		// Is the logger configured to output messages at the supplied level?
    		enabledFor: function (lvl) {
    			var filterLevel = this.context.filterLevel;
    			return lvl.value >= filterLevel.value;
    		},

    		trace: function () {
    			this.invoke(Logger.TRACE, arguments);
    		},

    		debug: function () {
    			this.invoke(Logger.DEBUG, arguments);
    		},

    		info: function () {
    			this.invoke(Logger.INFO, arguments);
    		},

    		warn: function () {
    			this.invoke(Logger.WARN, arguments);
    		},

    		error: function () {
    			this.invoke(Logger.ERROR, arguments);
    		},

    		time: function (label) {
    			if (typeof label === 'string' && label.length > 0) {
    				this.invoke(Logger.TIME, [ label, 'start' ]);
    			}
    		},

    		timeEnd: function (label) {
    			if (typeof label === 'string' && label.length > 0) {
    				this.invoke(Logger.TIME, [ label, 'end' ]);
    			}
    		},

    		// Invokes the logger callback if it's not being filtered.
    		invoke: function (level, msgArgs) {
    			if (logHandler && this.enabledFor(level)) {
    				logHandler(msgArgs, merge({ level: level }, this.context));
    			}
    		}
    	};

    	// Protected instance which all calls to the to level `Logger` module will be routed through.
    	var globalLogger = new ContextualLogger({ filterLevel: Logger.OFF });

    	// Configure the global Logger instance.
    	(function() {
    		// Shortcut for optimisers.
    		var L = Logger;

    		L.enabledFor = bind(globalLogger, globalLogger.enabledFor);
    		L.trace = bind(globalLogger, globalLogger.trace);
    		L.debug = bind(globalLogger, globalLogger.debug);
    		L.time = bind(globalLogger, globalLogger.time);
    		L.timeEnd = bind(globalLogger, globalLogger.timeEnd);
    		L.info = bind(globalLogger, globalLogger.info);
    		L.warn = bind(globalLogger, globalLogger.warn);
    		L.error = bind(globalLogger, globalLogger.error);

    		// Don't forget the convenience alias!
    		L.log = L.info;
    	}());

    	// Set the global logging handler.  The supplied function should expect two arguments, the first being an arguments
    	// object with the supplied log messages and the second being a context object which contains a hash of stateful
    	// parameters which the logging function can consume.
    	Logger.setHandler = function (func) {
    		logHandler = func;
    	};

    	// Sets the global logging filter level which applies to *all* previously registered, and future Logger instances.
    	// (note that named loggers (retrieved via `Logger.get`) can be configured independently if required).
    	Logger.setLevel = function(level) {
    		// Set the globalLogger's level.
    		globalLogger.setLevel(level);

    		// Apply this level to all registered contextual loggers.
    		for (var key in contextualLoggersByNameMap) {
    			if (contextualLoggersByNameMap.hasOwnProperty(key)) {
    				contextualLoggersByNameMap[key].setLevel(level);
    			}
    		}
    	};

    	// Gets the global logging filter level
    	Logger.getLevel = function() {
    		return globalLogger.getLevel();
    	};

    	// Retrieve a ContextualLogger instance.  Note that named loggers automatically inherit the global logger's level,
    	// default context and log handler.
    	Logger.get = function (name) {
    		// All logger instances are cached so they can be configured ahead of use.
    		return contextualLoggersByNameMap[name] ||
    			(contextualLoggersByNameMap[name] = new ContextualLogger(merge({ name: name }, globalLogger.context)));
    	};

    	// CreateDefaultHandler returns a handler function which can be passed to `Logger.setHandler()` which will
    	// write to the window's console object (if present); the optional options object can be used to customise the
    	// formatter used to format each log message.
    	Logger.createDefaultHandler = function (options) {
    		options = options || {};

    		options.formatter = options.formatter || function defaultMessageFormatter(messages, context) {
    			// Prepend the logger's name to the log message for easy identification.
    			if (context.name) {
    				messages.unshift("[" + context.name + "]");
    			}
    		};

    		// Map of timestamps by timer labels used to track `#time` and `#timeEnd()` invocations in environments
    		// that don't offer a native console method.
    		var timerStartTimeByLabelMap = {};

    		// Support for IE8+ (and other, slightly more sane environments)
    		var invokeConsoleMethod = function (hdlr, messages) {
    			Function.prototype.apply.call(hdlr, console, messages);
    		};

    		// Check for the presence of a logger.
    		if (typeof console === "undefined") {
    			return function () { /* no console */ };
    		}

    		return function(messages, context) {
    			// Convert arguments object to Array.
    			messages = Array.prototype.slice.call(messages);

    			var hdlr = console.log;
    			var timerLabel;

    			if (context.level === Logger.TIME) {
    				timerLabel = (context.name ? '[' + context.name + '] ' : '') + messages[0];

    				if (messages[1] === 'start') {
    					if (console.time) {
    						console.time(timerLabel);
    					}
    					else {
    						timerStartTimeByLabelMap[timerLabel] = new Date().getTime();
    					}
    				}
    				else {
    					if (console.timeEnd) {
    						console.timeEnd(timerLabel);
    					}
    					else {
    						invokeConsoleMethod(hdlr, [ timerLabel + ': ' +
    							(new Date().getTime() - timerStartTimeByLabelMap[timerLabel]) + 'ms' ]);
    					}
    				}
    			}
    			else {
    				// Delegate through to custom warn/error loggers if present on the console.
    				if (context.level === Logger.WARN && console.warn) {
    					hdlr = console.warn;
    				} else if (context.level === Logger.ERROR && console.error) {
    					hdlr = console.error;
    				} else if (context.level === Logger.INFO && console.info) {
    					hdlr = console.info;
    				} else if (context.level === Logger.DEBUG && console.debug) {
    					hdlr = console.debug;
    				} else if (context.level === Logger.TRACE && console.trace) {
    					hdlr = console.trace;
    				}

    				options.formatter(messages, context);
    				invokeConsoleMethod(hdlr, messages);
    			}
    		};
    	};

    	// Configure and example a Default implementation which writes to the `window.console` (if present).  The
    	// `options` hash can be used to configure the default logLevel and provide a custom message formatter.
    	Logger.useDefaults = function(options) {
    		Logger.setLevel(options && options.defaultLevel || Logger.DEBUG);
    		Logger.setHandler(Logger.createDefaultHandler(options));
    	};

    	// Createa an alias to useDefaults to avoid reaking a react-hooks rule.
    	Logger.setDefaults = Logger.useDefaults;

    	// Export to popular environments boilerplate.
    	if (module.exports) {
    		module.exports = Logger;
    	}
    	else {
    		Logger._prevLogger = global.Logger;

    		Logger.noConflict = function () {
    			global.Logger = Logger._prevLogger;
    			return Logger;
    		};

    		global.Logger = Logger;
    	}
    }(commonjsGlobal));
    }(logger));

    var Logger = logger.exports;

    Logger.useDefaults({
        defaultLevel: Logger.DEBUG,
        formatter: (messages, context) => {
            messages.unshift(`[${context.name}] `);
        },
    });

    var MediaFamily;
    (function (MediaFamily) {
        MediaFamily["Audio"] = "AUDIO";
        MediaFamily["Video"] = "VIDEO";
    })(MediaFamily || (MediaFamily = {}));
    var MediaContent;
    (function (MediaContent) {
        MediaContent["Main"] = "MAIN";
        MediaContent["Slides"] = "SLIDES";
    })(MediaContent || (MediaContent = {}));
    var Policy;
    (function (Policy) {
        Policy["ActiveSpeaker"] = "active-speaker";
        Policy["ReceiverSelected"] = "receiver-selected";
    })(Policy || (Policy = {}));
    var MediaType;
    (function (MediaType) {
        MediaType["VideoMain"] = "VIDEO-MAIN";
        MediaType["VideoSlides"] = "VIDEO-SLIDES";
        MediaType["AudioMain"] = "AUDIO-MAIN";
        MediaType["AudioSlides"] = "AUDIO-SLIDES";
    })(MediaType || (MediaType = {}));

    var JmpMsgType;
    (function (JmpMsgType) {
        JmpMsgType["MediaRequest"] = "mediaRequest";
        JmpMsgType["MediaRequestAck"] = "mediaRequestAck";
        JmpMsgType["MediaRequestStatus"] = "mediaRequestStatus";
        JmpMsgType["MediaRequestStatusAck"] = "mediaRequestStatusAck";
        JmpMsgType["SourceAdvertisement"] = "sourceAdvertisement";
        JmpMsgType["SourceAdvertisementAck"] = "sourceAdvertisementAck";
        JmpMsgType["ActiveSpeakerNotification"] = "activeSpeakerNotification";
    })(JmpMsgType || (JmpMsgType = {}));

    var JmpSessionEvents;
    (function (JmpSessionEvents) {
        JmpSessionEvents["ActiveSpeaker"] = "active-speaker";
        JmpSessionEvents["MediaRequestReceived"] = "media-request-received";
        JmpSessionEvents["MediaRequestStatusReceived"] = "media-request-status-received";
        JmpSessionEvents["SourceAdvertisementReceived"] = "source-advertisement-received";
    })(JmpSessionEvents || (JmpSessionEvents = {}));

    var EncodedTransformType;
    (function (EncodedTransformType) {
        EncodedTransformType["AudioLevelMonitor"] = "audio-level-monitor";
    })(EncodedTransformType || (EncodedTransformType = {}));
    var MainMsgType;
    (function (MainMsgType) {
        MainMsgType["GetMetadata"] = "get-metadata";
        MainMsgType["ClearMetadata"] = "clear-metadata";
    })(MainMsgType || (MainMsgType = {}));
    var WorkerMsgType;
    (function (WorkerMsgType) {
        WorkerMsgType["Response"] = "response";
        WorkerMsgType["Log"] = "log";
    })(WorkerMsgType || (WorkerMsgType = {}));

    const workerLogger = {
        info: (...args) => {
            postMessage({ type: WorkerMsgType.Log, level: 'info', messageArgs: args });
        },
        warn: (...args) => {
            postMessage({ type: WorkerMsgType.Log, level: 'warn', messageArgs: args });
        },
        error: (...args) => {
            postMessage({ type: WorkerMsgType.Log, level: 'error', messageArgs: args });
        },
    };
    const collectedMetadata = {};
    const createAudioLevelMonitorTransform = (multistreamConnectionId, encodedTransformId) => {
        if (!(multistreamConnectionId in collectedMetadata)) {
            collectedMetadata[multistreamConnectionId] = {
                [MediaType.AudioMain]: {},
                [MediaType.AudioSlides]: {},
                [MediaType.VideoMain]: {},
                [MediaType.VideoSlides]: {},
            };
        }
        collectedMetadata[multistreamConnectionId][MediaType.AudioMain][encodedTransformId] = {
            maxAudioLevel: undefined,
        };
        const collectedStreamMetadata = collectedMetadata[multistreamConnectionId][MediaType.AudioMain][encodedTransformId];
        workerLogger.info(`creating encoded transform for ${multistreamConnectionId}:${encodedTransformId}`);
        return new TransformStream({
            transform: (encodedFrame, controller) => {
                const metadata = encodedFrame.getMetadata();
                if (!collectedStreamMetadata.maxAudioLevel ||
                    metadata.audioLevel > collectedStreamMetadata.maxAudioLevel) {
                    collectedStreamMetadata.maxAudioLevel = metadata.audioLevel;
                }
                controller.enqueue(encodedFrame);
            },
        });
    };
    addEventListener('rtctransform', (event) => {
        let transform;
        if (!event.transformer.options || !event.transformer.options.type) {
            workerLogger.warn('missing or invalid transformer options=', event.transformer.options);
            return;
        }
        const options = event.transformer.options;
        const { encodedTransformId, multistreamConnectionId, type } = options;
        switch (type) {
            case EncodedTransformType.AudioLevelMonitor:
                transform = createAudioLevelMonitorTransform(multistreamConnectionId, encodedTransformId);
                break;
            default:
                workerLogger.warn('unexpected transformer type=', type);
        }
        if (transform) {
            event.transformer.readable.pipeThrough(transform).pipeTo(event.transformer.writable);
        }
    });
    addEventListener('message', (event) => {
        var _a, _b;
        const { requestId } = event.data;
        const { type } = event.data.payload;
        let responseData;
        switch (type) {
            case MainMsgType.GetMetadata: {
                const { multistreamConnectionId, mediaType, encodedTransformId } = event.data.payload;
                responseData = (_b = (_a = collectedMetadata[multistreamConnectionId]) === null || _a === void 0 ? void 0 : _a[mediaType]) === null || _b === void 0 ? void 0 : _b[encodedTransformId];
                break;
            }
            case MainMsgType.ClearMetadata: {
                const { multistreamConnectionId } = event.data.payload;
                delete collectedMetadata[multistreamConnectionId];
                break;
            }
            default:
                workerLogger.warn('unexpected message type=', type);
                break;
        }
        postMessage({
            type: WorkerMsgType.Response,
            requestId,
            responseData,
        });
    });
    workerLogger.info('Worker fully started.');

})();

', null, false);
+/* eslint-enable */
+
+class WorkerManager {
+    constructor() {
+        this.requestsInProgress = new Map();
+        this.lastRequestId = 0;
+    }
+    startWorker() {
+        if (this.worker) {
+            logger.info('Worker is already started');
+            return;
+        }
+        logger.info('Starting worker...');
+        this.worker = new WorkerFactory();
+        this.worker.onmessage = this.messageHandler.bind(this);
+    }
+    stopWorker() {
+    }
+    getWorker() {
+        return this.worker;
+    }
+    messageHandler(event) {
+        const { type } = event.data;
+        switch (type) {
+            case WorkerMsgType.Response: {
+                const { requestId, responseData } = event.data;
+                const request = this.requestsInProgress.get(requestId);
+                if (request) {
+                    request.resolve(responseData);
+                    this.requestsInProgress.delete(requestId);
+                }
+                else {
+                    logger.warn(`received response for unknown requestId: ${requestId}`);
+                }
+                break;
+            }
+            case WorkerMsgType.Log: {
+                const { messageArgs, level } = event.data;
+                switch (level) {
+                    case 'info':
+                        logger.log(`worker: `, ...messageArgs);
+                        break;
+                    case 'warn':
+                        logger.warn(`worker: `, ...messageArgs);
+                        break;
+                    case 'error':
+                        logger.error(`worker: `, ...messageArgs);
+                        break;
+                    default:
+                        logger.log(`worker (unsupported log level ${level}): `, ...messageArgs);
+                        break;
+                }
+                break;
+            }
+            default:
+                logger.warn(`received unknown message type from worker: ${type}`);
+        }
+    }
+    sendRequestToWorker(payload) {
+        return new Promise((resolve, reject) => {
+            if (!this.worker) {
+                reject(new Error('Worker is not started'));
+                return;
+            }
+            const requestId = this.lastRequestId++;
+            this.requestsInProgress.set(requestId, { resolve, reject });
+            this.worker.postMessage({
+                requestId,
+                payload,
+            });
+        });
+    }
+}
+WorkerManager.workerManagerInstance = new WorkerManager();
+function getWorkerManager() {
+    return WorkerManager.workerManagerInstance;
+}
+
 function toMediaStreamTrackKind(mediaType) {
     return [exports.MediaType.VideoMain, exports.MediaType.VideoSlides].includes(mediaType)
         ? exports.MediaStreamTrackKind.Video
@@ -15500,7 +15780,9 @@ const defaultMultistreamConnectionOptions = {
     disableAudioMainDtx: true,
     preferredStartingBitrateKbps: defaultStartBitrateKbps,
     metricsCallback: () => { },
+    enableInboundAudioLevelMonitoring: false,
 };
+let staticIdCounter = 0;
 class MultistreamConnection extends EventEmitter$2 {
     constructor(userOptions = {}) {
         super();
@@ -15513,9 +15795,11 @@ class MultistreamConnection extends EventEmitter$2 {
         this.offerAnswerQueue = new AsyncQueue();
         this.currentCreateOfferId = 0;
         this.metadata = { isMediaBypassEdge: false };
+        this.id = `mc-${staticIdCounter++}`;
         this.options = Object.assign(Object.assign({}, defaultMultistreamConnectionOptions), userOptions);
         logger.info(`Creating multistream connection with options ${JSON.stringify(this.options)}`);
         this.metricsCallback = this.options.metricsCallback;
+        this.startWorkerIfNeeded();
         this.initializePeerConnection();
         this.overuseStateManager = new OveruseStateManager((overuseState) => this.overuseUpdateCallback(overuseState));
         this.overuseStateManager.start();
@@ -15529,6 +15813,15 @@ class MultistreamConnection extends EventEmitter$2 {
         this.createSendTransceiver(exports.MediaType.VideoSlides, slidesSceneId, videoSlidesEncodingOptions);
         this.createSendTransceiver(exports.MediaType.AudioSlides, slidesSceneId);
     }
+    startWorkerIfNeeded() {
+        if (this.options.enableInboundAudioLevelMonitoring) {
+            if (WebCapabilities.supportsEncodedStreamTransforms() !== CapabilityState.CAPABLE) {
+                logger.warn('RTCRtpScriptTransform is not supported in this browser, skipping inbound audio level monitoring.');
+                return;
+            }
+            getWorkerManager().startWorker();
+        }
+    }
     initializePeerConnection() {
         this.pc = new PeerConnection({
             iceServers: this.options.iceServers,
@@ -15852,6 +16145,10 @@ SCTP Max Message Size: ${maxMessageSize}`);
         });
         this.jmpSessions.forEach((jmpSession) => jmpSession.close());
         this.pc.close();
+        getWorkerManager().sendRequestToWorker({
+            type: MainMsgType.ClearMetadata,
+            multistreamConnectionId: this.id,
+        });
     }
     sendMediaRequestStatus(mediaType) {
         var _a;
@@ -15923,6 +16220,7 @@ SCTP Max Message Size: ${maxMessageSize}`);
             direction: 'recvonly',
         });
         const mid = this.midPredictor.getNextMid(mediaType);
+        const doAudioLevelMonitoring = this.options.enableInboundAudioLevelMonitoring && mediaType === exports.MediaType.AudioMain;
         const munger = new IngressSdpMunger();
         const recvOnlyTransceiver = new ReceiveOnlyTransceiver({
             rtcRtpTransceiver,
@@ -15930,6 +16228,23 @@ SCTP Max Message Size: ${maxMessageSize}`);
             mediaType,
             munger,
         });
+        if (doAudioLevelMonitoring) {
+            const encodedTransformId = `INBOUND-${mediaType}-${mid}`;
+            try {
+                this.setupEncodedTransform(rtcRtpTransceiver.receiver, encodedTransformId, EncodedTransformType.AudioLevelMonitor);
+                recvOnlyTransceiver.setEncodedStreamMetadataCallback(() => __awaiter(this, void 0, void 0, function* () {
+                    return getWorkerManager().sendRequestToWorker({
+                        type: MainMsgType.GetMetadata,
+                        mediaType,
+                        encodedTransformId,
+                        multistreamConnectionId: this.id,
+                    });
+                }));
+            }
+            catch (e) {
+                logger.warn(`Failed to setup encoded transform for ${encodedTransformId} audio level monitoring: ${e}`);
+            }
+        }
         if (getMediaFamily(mediaType) === exports.MediaFamily.Video) {
             recvOnlyTransceiver.setCodecParameters({
                 'sps-pps-idr-in-keyframe': '1',
@@ -16418,6 +16733,21 @@ SCTP Max Message Size: ${maxMessageSize}`);
             videoSlides: this.getCsiByMediaType(exports.MediaType.VideoSlides),
         };
     }
+    setupEncodedTransform(receiverOrSender, id, type) {
+        if (WebCapabilities.supportsEncodedStreamTransforms() !== CapabilityState.CAPABLE) {
+            throw new Error('encoded stream transport is not supported in this browser.');
+        }
+        if (!getWorkerManager().getWorker()) {
+            throw new Error('no worker available for encoded stream transforms.');
+        }
+        const options = {
+            type,
+            encodedTransformId: id,
+            multistreamConnectionId: this.id,
+        };
+        receiverOrSender.transform = new window.RTCRtpScriptTransform(getWorkerManager().getWorker(), options);
+        logger.log(`started "${type}" transform with id=${id} on connection ${this.id}`);
+    }
 }
 
 class StreamRequest {