@agilemotion/oui-react-js 2.0.15 → 2.0.17

package/dist/components/media/audioLevelMeter.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startAudioLevelMeter = startAudioLevelMeter;
+// Lightweight per-stream audio level meter for active-speaker highlighting.
+//
+// It only READS a MediaStream via a Web Audio AnalyserNode (never connected to
+// the context destination), so it has no effect on playback — the <audio>
+// element that actually plays the stream is independent. A single shared
+// AudioContext is reused across all meters (browsers cap the number of
+// contexts, and a meeting can have several participants).
+
+let sharedCtx = null;
+function getSharedContext() {
+  if (!sharedCtx) {
+    const AudioCtx = window.AudioContext || window.webkitAudioContext;
+    if (!AudioCtx) return null;
+    sharedCtx = new AudioCtx();
+  }
+  // Autoplay policies can leave the context suspended until a user gesture;
+  // by the time someone is in a meeting they've interacted, so this resolves.
+  if (sharedCtx.state === 'suspended') {
+    sharedCtx.resume().catch(() => {});
+  }
+  return sharedCtx;
+}
+
+/**
+ * Start metering a stream's audio level.
+ *
+ * @param {MediaStream} stream      the stream to measure
+ * @param {(level:number)=>void} onLevel  called with a 0..100 level, throttled
+ * @param {number} [intervalMs=100] minimum gap between onLevel callbacks
+ * @returns {() => void} stop function — disconnects nodes and stops the loop
+ */
+function startAudioLevelMeter(stream, onLevel) {
+  let intervalMs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
+  let stopped = false;
+  let raf = null;
+  let source = null;
+  let analyser = null;
+  let lastEmit = 0;
+  let lastLevel = -1;
+  try {
+    if (!stream || stream.getAudioTracks().length === 0) {
+      return () => {};
+    }
+    const ctx = getSharedContext();
+    if (!ctx) return () => {};
+    source = ctx.createMediaStreamSource(stream);
+    analyser = ctx.createAnalyser();
+    analyser.fftSize = 512;
+    analyser.smoothingTimeConstant = 0.6;
+    source.connect(analyser); // NB: analyser is NOT connected onward — read-only.
+
+    const data = new Uint8Array(analyser.frequencyBinCount);
+    const tick = () => {
+      if (stopped) return;
+      raf = requestAnimationFrame(tick);
+      const now = typeof performance !== 'undefined' && performance.now ? performance.now() : 0;
+      if (now - lastEmit < intervalMs) return;
+      lastEmit = now;
+      analyser.getByteTimeDomainData(data);
+      let sumSquares = 0;
+      for (let i = 0; i < data.length; i++) {
+        const v = (data[i] - 128) / 128; // -1..1
+        sumSquares += v * v;
+      }
+      const rms = Math.sqrt(sumSquares / data.length); // 0..1
+      // Scale + quantise so tiny fluctuations don't spam re-renders.
+      const level = Math.min(100, Math.round(rms * 200 / 2) * 2);
+      if (level !== lastLevel) {
+        lastLevel = level;
+        onLevel(level);
+      }
+    };
+    raf = requestAnimationFrame(tick);
+  } catch (e) {
+    // Web Audio unavailable / stream not analysable — degrade silently.
+    return () => {};
+  }
+  return () => {
+    stopped = true;
+    if (raf) cancelAnimationFrame(raf);
+    try {
+      source && source.disconnect();
+    } catch (e) {/* noop */}
+    try {
+      analyser && analyser.disconnect();
+    } catch (e) {/* noop */}
+    // Intentionally do NOT close the shared context — other meters use it.
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["sharedCtx","getSharedContext","AudioCtx","window","AudioContext","webkitAudioContext","state","resume","catch","startAudioLevelMeter","stream","onLevel","intervalMs","arguments","length","undefined","stopped","raf","source","analyser","lastEmit","lastLevel","getAudioTracks","ctx","createMediaStreamSource","createAnalyser","fftSize","smoothingTimeConstant","connect","data","Uint8Array","frequencyBinCount","tick","requestAnimationFrame","now","performance","getByteTimeDomainData","sumSquares","i","v","rms","Math","sqrt","level","min","round","e","cancelAnimationFrame","disconnect"],"sources":["../../../src/lib/components/media/audioLevelMeter.js"],"sourcesContent":["// Lightweight per-stream audio level meter for active-speaker highlighting.\n//\n// It only READS a MediaStream via a Web Audio AnalyserNode (never connected to\n// the context destination), so it has no effect on playback — the <audio>\n// element that actually plays the stream is independent. A single shared\n// AudioContext is reused across all meters (browsers cap the number of\n// contexts, and a meeting can have several participants).\n\nlet sharedCtx = null;\n\nfunction getSharedContext() {\n    if (!sharedCtx) {\n        const AudioCtx = window.AudioContext || window.webkitAudioContext;\n        if (!AudioCtx) return null;\n        sharedCtx = new AudioCtx();\n    }\n    // Autoplay policies can leave the context suspended until a user gesture;\n    // by the time someone is in a meeting they've interacted, so this resolves.\n    if (sharedCtx.state === 'suspended') {\n        sharedCtx.resume().catch(() => {});\n    }\n    return sharedCtx;\n}\n\n/**\n * Start metering a stream's audio level.\n *\n * @param {MediaStream} stream      the stream to measure\n * @param {(level:number)=>void} onLevel  called with a 0..100 level, throttled\n * @param {number} [intervalMs=100] minimum gap between onLevel callbacks\n * @returns {() => void} stop function — disconnects nodes and stops the loop\n */\nexport function startAudioLevelMeter(stream, onLevel, intervalMs = 100) {\n    let stopped = false;\n    let raf = null;\n    let source = null;\n    let analyser = null;\n    let lastEmit = 0;\n    let lastLevel = -1;\n\n    try {\n        if (!stream || stream.getAudioTracks().length === 0) {\n            return () => {};\n        }\n        const ctx = getSharedContext();\n        if (!ctx) return () => {};\n\n        source = ctx.createMediaStreamSource(stream);\n        analyser = ctx.createAnalyser();\n        analyser.fftSize = 512;\n        analyser.smoothingTimeConstant = 0.6;\n        source.connect(analyser); // NB: analyser is NOT connected onward — read-only.\n\n        const data = new Uint8Array(analyser.frequencyBinCount);\n\n        const tick = () => {\n            if (stopped) return;\n            raf = requestAnimationFrame(tick);\n\n            const now = (typeof performance !== 'undefined' && performance.now)\n                ? performance.now() : 0;\n            if (now - lastEmit < intervalMs) return;\n            lastEmit = now;\n\n            analyser.getByteTimeDomainData(data);\n            let sumSquares = 0;\n            for (let i = 0; i < data.length; i++) {\n                const v = (data[i] - 128) / 128; // -1..1\n                sumSquares += v * v;\n            }\n            const rms = Math.sqrt(sumSquares / data.length); // 0..1\n            // Scale + quantise so tiny fluctuations don't spam re-renders.\n            const level = Math.min(100, Math.round((rms * 200) / 2) * 2);\n            if (level !== lastLevel) {\n                lastLevel = level;\n                onLevel(level);\n            }\n        };\n        raf = requestAnimationFrame(tick);\n    } catch (e) {\n        // Web Audio unavailable / stream not analysable — degrade silently.\n        return () => {};\n    }\n\n    return () => {\n        stopped = true;\n        if (raf) cancelAnimationFrame(raf);\n        try { source && source.disconnect(); } catch (e) { /* noop */ }\n        try { analyser && analyser.disconnect(); } catch (e) { /* noop */ }\n        // Intentionally do NOT close the shared context — other meters use it.\n    };\n}\n"],"mappings":"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","ignoreList":[]}