@vindral/web-sdk 4.5.1 → 4.6.0

package/BddIq5-p.js

@@ -0,0 +1,154 @@
+import { n as e, t } from "./BsfwXDui.js";
+import { t as n } from "./DrWNJwZx.js";
+import { t as r } from "./BKeRxR4O.js";
+import { i, n as a, t as o } from "./CbyVl6wP.js";
+//#region ../../libs/web-sdk/src/decoders/WebCodecsAudioDecoderContext.ts
+var s, c = globalThis, l = (e) => {
+	var t, n;
+	if (!e) return {
+		description: e,
+		preSkip: 0
+	};
+	let r = e instanceof ArrayBuffer ? new Uint8Array(e) : new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+	if (!(r.byteLength >= 19 && new TextDecoder().decode(r.subarray(0, 8)) === "OpusHead")) return {
+		description: e,
+		preSkip: 0
+	};
+	let i = r.slice();
+	return i[10] = 0, i[11] = 0, {
+		description: i,
+		preSkip: ((t = r[10]) == null ? 0 : t) | ((n = r[11]) == null ? 0 : n) << 8
+	};
+}, u = class {
+	constructor(s) {
+		var c = this;
+		e(this, "decodedSamples", []), e(this, "decoder", null), e(this, "logger", void 0), e(this, "initSegments", /* @__PURE__ */ new Map()), e(this, "previousSample", void 0), e(this, "previousCodec", void 0), e(this, "pendingSamples", new n(Infinity)), e(this, "priming", { remaining: 0 }), e(this, "sentCount", 0), e(this, "doneCount", 0), e(this, "errors", new n(10)), e(this, "resetDecoderState", () => {
+			this.pendingSamples.clear(), this.doneCount = this.sentCount, this.previousSample = void 0, this.previousCodec = void 0;
+		}), e(this, "dropUndecoded", (e) => {
+			for (; this.doneCount < e && this.pendingSamples.pop();) this.doneCount++;
+		}), e(this, "ensureDecoder", () => ((!this.decoder || this.decoder.state === "closed") && (this.decoder = this.createDecoder()), this.decoder)), e(this, "createDecoder", () => new AudioDecoder({
+			output: (e) => {
+				let t = this.pendingSamples.pop();
+				if (!t) {
+					e.close();
+					return;
+				}
+				this.doneCount++;
+				let { sample: n, decodeStartTime: i, priming: a } = t;
+				try {
+					let t = e.numberOfFrames, o = e.numberOfChannels, s = e.sampleRate, c = e.duration, l = Math.min(t, Math.round(a.remaining * s / 48e3));
+					if (a.remaining = Math.max(0, a.remaining - Math.round(l * 48e3 / s)), l === t && t > 0) return;
+					let u = new Float32Array((t - l) * o);
+					e.copyTo(u, {
+						planeIndex: 0,
+						format: "f32",
+						frameOffset: l
+					});
+					let d = l > 0 ? Math.round((t - l) * n.timescale / s) : typeof c == "number" && Number.isFinite(c) ? Math.max(0, Math.round(c * n.timescale / 1e6)) : n.duration, f = r(r({}, n), {}, {
+						timestamp: n.timestamp + Math.round(l * n.timescale / s),
+						duration: d,
+						type: "audio",
+						format: "f32",
+						data: u,
+						sampleRate: s,
+						channels: o,
+						statistics: {
+							decodeTime: Math.max(performance.now() - i, 0),
+							transportTimeFromWorker: 0,
+							transportTimeToWorker: 0,
+							samplesInBatch: 1
+						}
+					});
+					this.decodedSamples.push(f);
+				} finally {
+					e.close();
+				}
+			},
+			error: (e) => {
+				this.logger.error("Decoder error:", e.name, e.message), this.resetDecoderState(), this.errors.push(e);
+			}
+		})), e(this, "buildCodecString", o), e(this, "getDescription", (e, t) => {
+			let n = this.initSegments.get(t.renditionId);
+			if (n && n.data.byteLength > 0 && n.codec === e) return n.data;
+			if (e === "opus") return a(t.channels, t.sampleRate);
+			if (e === "aac") return i(t.channels, t.sampleRate);
+		}), e(this, "reset", () => {
+			this.decodedSamples = [], this.decoder && this.decoder.state !== "closed" && this.decoder.reset(), this.resetDecoderState();
+		}), e(this, "unload", () => {
+			this.reset(), this.decoder && this.decoder.state !== "closed" && this.decoder.close(), this.decoder = null;
+		}), e(this, "initSegment", (e) => {
+			this.initSegments.set(e.renditionId, e);
+		}), e(this, "enqueue", (e) => {
+			var t, n;
+			let r = this.ensureDecoder(), i = e.codec, a = ((t = this.previousSample) == null ? void 0 : t.channelId) !== e.channelId, o = ((n = this.previousSample) == null ? void 0 : n.renditionId) !== e.renditionId, s = this.previousCodec !== i;
+			if (!this.previousSample || a || o || s) {
+				if (this.previousSample && r.state === "configured") {
+					let e = this.sentCount;
+					r.flush().then(() => this.dropUndecoded(e), (e) => {
+						this.logger.warn("Failed to flush before reconfiguration:", e);
+					});
+				}
+				let t = this.buildCodecString(i), { description: n, preSkip: a } = i === "opus" ? l(this.getDescription(i, e)) : {
+					description: this.getDescription(i, e),
+					preSkip: 0
+				}, o = {
+					codec: t,
+					sampleRate: e.sampleRate,
+					numberOfChannels: e.channels,
+					description: n
+				};
+				try {
+					r.configure(o), this.previousCodec = i, this.priming = { remaining: a };
+				} catch (t) {
+					this.logger.error(`Failed to configure decoder for ${i} (rendition ${e.renditionId}), dropping sample`, t), this.errors.push(t instanceof Error ? t : /* @__PURE__ */ Error(`Failed to configure decoder for ${i}`)), r.state === "configured" && r.reset(), this.resetDecoderState(), this.ensureDecoder();
+					return;
+				}
+			}
+			if (e.timescale <= 0) {
+				this.logger.error(`Invalid timescale ${e.timescale} in sample, dropping sample`);
+				return;
+			}
+			this.previousSample = e;
+			let c = Math.floor(1e6 * e.timestamp / e.timescale), u = Math.floor(1e6 * e.duration / e.timescale), d;
+			try {
+				d = new EncodedAudioChunk({
+					type: "key",
+					timestamp: c,
+					duration: u > 0 ? u : void 0,
+					data: e.data
+				});
+			} catch (e) {
+				this.logger.error("Failed to create chunk:", e);
+				return;
+			}
+			this.pendingSamples.push({
+				sample: e,
+				decodeStartTime: performance.now(),
+				priming: this.priming
+			}), this.sentCount++;
+			try {
+				r.decode(d);
+			} catch (e) {
+				this.logger.error("Failed to decode chunk:", e), this.pendingSamples.popLast(), this.sentCount--, r.state === "closed" && (this.resetDecoderState(), this.ensureDecoder());
+			}
+		}), e(this, "flush", t(function* () {
+			if (c.decoder && c.decoder.state === "configured") try {
+				let e = c.sentCount;
+				yield c.decoder.flush(), c.dropUndecoded(e);
+			} catch (e) {
+				c.logger.error("Failed to flush decoder:", e), c.resetDecoderState();
+			}
+		})), e(this, "error", () => this.errors.pop()), e(this, "take", () => this.decodedSamples.shift()), this.logger = s, this.decoder = this.createDecoder();
+	}
+};
+s = u, e(u, "isSupported", () => c.AudioDecoder !== void 0), e(u, "create", function() {
+	var e = t(function* (e) {
+		if (!s.isSupported()) throw Error("WebCodecs AudioDecoder is not supported in this environment");
+		return new s(e);
+	});
+	return function(t) {
+		return e.apply(this, arguments);
+	};
+}());
+//#endregion
+export { u as WebCodecsAudioDecoderContext };