@vindral/web-sdk 4.1.10 → 4.2.0

package/BQEuFJLn.js

@@ -0,0 +1,206 @@
+var k = Object.defineProperty, I = Object.defineProperties;
+var T = Object.getOwnPropertyDescriptors;
+var w = Object.getOwnPropertySymbols;
+var M = Object.prototype.hasOwnProperty, C = Object.prototype.propertyIsEnumerable;
+var S = (s, e, t) => e in s ? k(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, b = (s, e) => {
+  for (var t in e || (e = {}))
+    M.call(e, t) && S(s, t, e[t]);
+  if (w)
+    for (var t of w(e))
+      C.call(e, t) && S(s, t, e[t]);
+  return s;
+}, y = (s, e) => I(s, T(e));
+var i = (s, e, t) => S(s, typeof e != "symbol" ? e + "" : e, t);
+var v = (s, e, t) => new Promise((r, n) => {
+  var a = (o) => {
+    try {
+      c(t.next(o));
+    } catch (d) {
+      n(d);
+    }
+  }, l = (o) => {
+    try {
+      c(t.throw(o));
+    } catch (d) {
+      n(d);
+    }
+  }, c = (o) => o.done ? r(o.value) : Promise.resolve(o.value).then(a, l);
+  c((t = t.apply(s, e)).next());
+});
+import { F as D, a as q, b as R, c as O } from "./DBHv5ggB.js";
+class E {
+  constructor() {
+    i(this, "map", /* @__PURE__ */ new Map());
+  }
+  enqueue(e, t) {
+    const r = this.map.get(e);
+    r ? r.push(t) : this.map.set(e, [t]);
+  }
+  dequeue(e) {
+    const t = this.map.get(e);
+    if (t && t.length > 0) {
+      const r = t.shift();
+      return t.length === 0 && this.map.delete(e), r;
+    }
+  }
+  /**
+   * Dequeue by exact timestamp, falling back to the oldest pending entry
+   * when the decoder outputs a timestamp that differs from input.
+   *
+   * Safe for audio because all audio frames are independently decodable
+   * key frames — there's no B-frame reordering that could cause metadata
+   * mismatches like in video.
+   */
+  dequeueWithFallback(e) {
+    const t = this.dequeue(e);
+    if (t !== void 0) return t;
+    for (const [r, n] of this.map)
+      if (n.length > 0) {
+        const a = n.shift();
+        return n.length === 0 && this.map.delete(r), a;
+      }
+  }
+  removeLast(e) {
+    const t = this.map.get(e);
+    !t || t.length === 0 || (t.pop(), t.length === 0 && this.map.delete(e));
+  }
+  clear() {
+    this.map.clear();
+  }
+}
+const $ = globalThis, u = class u {
+  constructor(e) {
+    i(this, "decodedSamples", []);
+    i(this, "decoder", null);
+    i(this, "logger");
+    i(this, "initSegments", /* @__PURE__ */ new Map());
+    i(this, "previousSample");
+    i(this, "previousCodec");
+    i(this, "pendingSamples", new E());
+    i(this, "errors", new D(10));
+    i(this, "resetDecoderState", () => {
+      this.pendingSamples.clear(), this.previousSample = void 0, this.previousCodec = void 0;
+    });
+    i(this, "ensureDecoder", () => ((!this.decoder || this.decoder.state === "closed") && (this.decoder = this.createDecoder()), this.decoder));
+    i(this, "createDecoder", () => new AudioDecoder({
+      output: (e) => {
+        const t = this.pendingSamples.dequeueWithFallback(e.timestamp);
+        if (!t) {
+          e.close();
+          return;
+        }
+        const { sample: r, decodeStartTime: n } = t;
+        try {
+          const a = e.numberOfFrames, l = e.numberOfChannels, c = e.sampleRate, o = e.timestamp, d = e.duration, p = new Float32Array(a * l);
+          e.copyTo(p, { planeIndex: 0, format: "f32" });
+          const h = Math.round(o * r.timescale / 1e6), f = typeof d == "number" && Number.isFinite(d) ? Math.max(0, Math.round(d * r.timescale / 1e6)) : r.duration, g = y(b({}, r), {
+            timestamp: h,
+            duration: f,
+            type: "audio",
+            format: "f32",
+            data: p,
+            sampleRate: c,
+            channels: l,
+            statistics: {
+              decodeTime: Math.max(performance.now() - n, 0),
+              transportTimeFromWorker: 0,
+              transportTimeToWorker: 0,
+              samplesInBatch: 1
+            }
+          });
+          this.decodedSamples.push(g);
+        } finally {
+          e.close();
+        }
+      },
+      error: (e) => {
+        this.logger.error("Decoder error:", e.name, e.message), this.resetDecoderState(), this.errors.push(e);
+      }
+    }));
+    /**
+     * Build AudioDecoderConfig codec string from audio codec type.
+     */
+    i(this, "buildCodecString", q);
+    /**
+     * Get the description for AudioDecoderConfig.
+     * Uses init segment data if available, otherwise generates codec-specific description.
+     */
+    i(this, "getDescription", (e, t) => {
+      const r = this.initSegments.get(t.renditionId);
+      if (r && r.data.byteLength > 0 && r.codec === e)
+        return r.data;
+      if (e === "opus")
+        return R(t.channels, t.sampleRate);
+      if (e === "aac")
+        return O(t.channels, t.sampleRate);
+    });
+    i(this, "unload", () => {
+      this.decodedSamples = [], this.resetDecoderState(), this.decoder && this.decoder.state !== "closed" && this.decoder.close(), this.decoder = null;
+    });
+    i(this, "initSegment", (e) => {
+      this.initSegments.set(e.renditionId, e);
+    });
+    i(this, "enqueue", (e) => {
+      var d, p;
+      const t = this.ensureDecoder(), r = e.codec, n = ((d = this.previousSample) == null ? void 0 : d.channelId) !== e.channelId, a = ((p = this.previousSample) == null ? void 0 : p.renditionId) !== e.renditionId, l = this.previousCodec !== r;
+      if (!this.previousSample || n || a || l) {
+        this.previousSample && t.state === "configured" && t.flush().catch((m) => {
+          this.logger.warn("Failed to flush before reconfiguration:", m);
+        });
+        const h = this.buildCodecString(r), f = this.getDescription(r, e), g = {
+          codec: h,
+          sampleRate: e.sampleRate,
+          numberOfChannels: e.channels,
+          description: f
+        };
+        try {
+          t.configure(g), this.previousCodec = r;
+        } catch (m) {
+          this.logger.error(
+            `Failed to configure decoder for ${r} (rendition ${e.renditionId}), dropping sample`,
+            m
+          ), this.errors.push(m instanceof Error ? m : new Error(`Failed to configure decoder for ${r}`)), this.resetDecoderState(), this.ensureDecoder();
+          return;
+        }
+      }
+      if (e.timescale <= 0) {
+        this.logger.error(`Invalid timescale ${e.timescale} in sample, dropping sample`);
+        return;
+      }
+      this.previousSample = e;
+      const c = Math.floor(1e6 * e.timestamp / e.timescale), o = Math.floor(1e6 * e.duration / e.timescale);
+      try {
+        const h = new EncodedAudioChunk({
+          // Audio codecs (Opus, AAC, MP3) always produce independently decodable frames
+          type: "key",
+          timestamp: c,
+          duration: o > 0 ? o : void 0,
+          data: e.data
+        });
+        this.pendingSamples.enqueue(c, { sample: e, decodeStartTime: performance.now() }), t.decode(h);
+      } catch (h) {
+        this.logger.error("Failed to decode chunk:", h), this.pendingSamples.removeLast(c), t.state === "closed" && (this.resetDecoderState(), this.ensureDecoder());
+      }
+    });
+    i(this, "flush", () => v(this, null, function* () {
+      if (this.decoder && this.decoder.state === "configured")
+        try {
+          yield this.decoder.flush();
+        } catch (e) {
+          this.logger.error("Failed to flush decoder:", e), this.resetDecoderState();
+        }
+    }));
+    i(this, "error", () => this.errors.pop());
+    i(this, "take", () => this.decodedSamples.shift());
+    this.logger = e, this.decoder = this.createDecoder();
+  }
+};
+i(u, "isSupported", () => typeof $.AudioDecoder != "undefined"), i(u, "create", (e) => v(null, null, function* () {
+  if (!u.isSupported())
+    throw new Error("WebCodecs AudioDecoder is not supported in this environment");
+  return new u(e);
+}));
+let F = u;
+export {
+  F as WebCodecsAudioDecoderContext
+};