@blockcast/mmt-render 0.1.0-main.c0e9e40265a1

package/dist/worklet/render-worklet.js

@@ -0,0 +1,403 @@
+"use strict";
+(() => {
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+  var __privateWrapper = (obj, member, setter, getter) => ({
+    set _(value) {
+      __privateSet(obj, member, value, setter);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  });
+
+  // src/audio/audio-ring-buffer.ts
+  var _buffer, _writeIndex, _readIndex, _stalled, _startupFrames, _resumeFrames, _resumeFollowsStartup, _hasStarted, _capacityHeadroomFrames, _timestampAnchors, _diagEnabled, _diagReads, _diagFillSum, _diagOverflowSamples, _AudioRingBuffer_instances, pruneTimestampAnchors_fn, refillFrames_fn;
+  var AudioRingBuffer = class {
+    constructor(config) {
+      __privateAdd(this, _AudioRingBuffer_instances);
+      __privateAdd(this, _buffer);
+      __privateAdd(this, _writeIndex, 0);
+      __privateAdd(this, _readIndex, 0);
+      __privateAdd(this, _stalled);
+      __privateAdd(this, _startupFrames);
+      __privateAdd(this, _resumeFrames);
+      __privateAdd(this, _resumeFollowsStartup);
+      __privateAdd(this, _hasStarted);
+      __privateAdd(this, _capacityHeadroomFrames);
+      __privateAdd(this, _timestampAnchors, []);
+      __privateAdd(this, _diagEnabled);
+      __privateAdd(this, _diagReads, 0);
+      __privateAdd(this, _diagFillSum, 0);
+      __privateAdd(this, _diagOverflowSamples, 0);
+      if (!Number.isInteger(config.channels) || config.channels <= 0) {
+        throw new Error("invalid channels");
+      }
+      if (!Number.isFinite(config.rate) || config.rate <= 0) {
+        throw new Error("invalid sample rate");
+      }
+      if (!Number.isFinite(config.latencyMs) || config.latencyMs <= 0) {
+        throw new Error("invalid latency");
+      }
+      const latencyFrames = Math.ceil(config.rate * (config.latencyMs / 1e3));
+      const startupFrames = config.startupFrames ?? latencyFrames;
+      const resumeFrames = config.resumeFrames ?? startupFrames;
+      const thresholdFrames = Math.max(startupFrames, resumeFrames);
+      const capacityFrames = config.capacityFrames ?? Math.max(latencyFrames, thresholdFrames);
+      if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {
+        throw new Error("invalid startup frames");
+      }
+      if (!Number.isSafeInteger(resumeFrames) || resumeFrames <= 0) {
+        throw new Error("invalid resume frames");
+      }
+      if (!Number.isSafeInteger(capacityFrames) || capacityFrames < thresholdFrames) {
+        throw new Error("invalid capacity frames");
+      }
+      this.channels = config.channels;
+      this.rate = config.rate;
+      __privateSet(this, _startupFrames, startupFrames);
+      __privateSet(this, _resumeFrames, resumeFrames);
+      __privateSet(this, _resumeFollowsStartup, config.resumeFrames === void 0);
+      __privateSet(this, _hasStarted, config.startUnstalled ?? false);
+      __privateSet(this, _capacityHeadroomFrames, capacityFrames - thresholdFrames);
+      __privateSet(this, _stalled, !(config.startUnstalled ?? false));
+      __privateSet(this, _diagEnabled, config.diag ?? false);
+      __privateSet(this, _buffer, Array.from(
+        { length: config.channels },
+        () => new Float32Array(capacityFrames)
+      ));
+    }
+    get stalled() {
+      return __privateGet(this, _stalled);
+    }
+    get startupFrames() {
+      return __privateGet(this, _startupFrames);
+    }
+    get capacity() {
+      return __privateGet(this, _buffer)[0].length;
+    }
+    get length() {
+      return __privateGet(this, _writeIndex) - __privateGet(this, _readIndex);
+    }
+    /** Timestamp of the next media sample after the PCM already emitted. */
+    get timestampUs() {
+      const anchor = __privateGet(this, _timestampAnchors)[0];
+      if (!anchor || anchor.sampleIndex > __privateGet(this, _readIndex)) return void 0;
+      return anchor.timestampUs + (__privateGet(this, _readIndex) - anchor.sampleIndex) / this.rate * 1e6;
+    }
+    write(timestampUs, data) {
+      if (data.length !== this.channels) throw new Error("wrong channel count");
+      if (!Number.isFinite(timestampUs)) throw new Error("invalid timestamp");
+      const samples = data[0].length;
+      if (samples === 0) return;
+      if (data.some((channel) => channel.length !== samples)) {
+        throw new Error("mismatched channel lengths");
+      }
+      const start = __privateGet(this, _writeIndex);
+      const end = start + samples;
+      __privateGet(this, _timestampAnchors).push({ sampleIndex: start, timestampUs });
+      const overflow = end - __privateGet(this, _readIndex) - this.capacity;
+      if (overflow > 0) {
+        __privateSet(this, _stalled, false);
+        __privateSet(this, _hasStarted, true);
+        __privateSet(this, _readIndex, __privateGet(this, _readIndex) + overflow);
+        if (__privateGet(this, _diagEnabled)) __privateSet(this, _diagOverflowSamples, __privateGet(this, _diagOverflowSamples) + overflow);
+        __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+      }
+      const refillFrames = __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+      if (__privateGet(this, _stalled) && end - __privateGet(this, _readIndex) >= refillFrames) {
+        __privateSet(this, _stalled, false);
+        __privateSet(this, _hasStarted, true);
+      }
+      for (let channel = 0; channel < this.channels; channel++) {
+        const src = data[channel];
+        const dst = __privateGet(this, _buffer)[channel];
+        for (let i = 0; i < samples; i++) {
+          dst[(start + i) % dst.length] = src[i];
+        }
+      }
+      __privateSet(this, _writeIndex, end);
+    }
+    read(output) {
+      if (output.length !== this.channels) throw new Error("wrong channel count");
+      if (__privateGet(this, _stalled)) return 0;
+      const available = this.length;
+      if (available === 0) {
+        __privateSet(this, _stalled, true);
+        return 0;
+      }
+      const requested = output[0].length;
+      const readSamples = Math.min(available, requested);
+      for (let channel = 0; channel < this.channels; channel++) {
+        const dst = output[channel];
+        const src = __privateGet(this, _buffer)[channel];
+        for (let i = 0; i < readSamples; i++) {
+          dst[i] = src[(__privateGet(this, _readIndex) + i) % src.length];
+        }
+        for (let i = readSamples; i < requested; i++) dst[i] = 0;
+      }
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + readSamples);
+      __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+      if (readSamples < requested) __privateSet(this, _stalled, true);
+      if (__privateGet(this, _diagEnabled)) {
+        __privateWrapper(this, _diagReads)._++;
+        __privateSet(this, _diagFillSum, __privateGet(this, _diagFillSum) + available);
+      }
+      return readSamples;
+    }
+    /** Clear queued PCM; optionally treat the next fill as post-start recovery. */
+    reset(startUnstalled = false, resumeAfterReset = false) {
+      __privateSet(this, _writeIndex, 0);
+      __privateSet(this, _readIndex, 0);
+      __privateSet(this, _stalled, !startUnstalled);
+      __privateSet(this, _hasStarted, startUnstalled || resumeAfterReset);
+      __privateSet(this, _timestampAnchors, []);
+      __privateSet(this, _diagReads, 0);
+      __privateSet(this, _diagFillSum, 0);
+      __privateSet(this, _diagOverflowSamples, 0);
+    }
+    /**
+     * Change the startup latency while preserving the configured storage
+     * headroom above its buffering thresholds. Active playout keeps draining
+     * retained PCM; a stalled buffer waits for its startup or resume threshold.
+     */
+    resize(latencyMs) {
+      if (!Number.isFinite(latencyMs) || latencyMs <= 0) {
+        throw new Error("invalid latency");
+      }
+      const newStartupFrames = Math.ceil(this.rate * (latencyMs / 1e3));
+      if (!Number.isSafeInteger(newStartupFrames) || newStartupFrames <= 0) {
+        throw new Error("invalid latency");
+      }
+      const newResumeFrames = __privateGet(this, _resumeFollowsStartup) ? newStartupFrames : __privateGet(this, _resumeFrames);
+      const newCapacity = Math.max(newStartupFrames, newResumeFrames) + __privateGet(this, _capacityHeadroomFrames);
+      if (!Number.isSafeInteger(newCapacity) || newCapacity < Math.max(newStartupFrames, newResumeFrames)) {
+        throw new Error("invalid capacity frames");
+      }
+      const wasStalled = __privateGet(this, _stalled);
+      __privateSet(this, _startupFrames, newStartupFrames);
+      __privateSet(this, _resumeFrames, newResumeFrames);
+      if (newCapacity === this.capacity) {
+        if (wasStalled && this.length >= __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this)) {
+          __privateSet(this, _stalled, false);
+          __privateSet(this, _hasStarted, true);
+        }
+        return;
+      }
+      const next = Array.from(
+        { length: this.channels },
+        () => new Float32Array(newCapacity)
+      );
+      const samplesToKeep = Math.min(this.length, newCapacity);
+      const copyStart = __privateGet(this, _writeIndex) - samplesToKeep;
+      for (let channel = 0; channel < this.channels; channel++) {
+        const src = __privateGet(this, _buffer)[channel];
+        const dst = next[channel];
+        for (let i = 0; i < samplesToKeep; i++) {
+          const sampleIndex = copyStart + i;
+          dst[sampleIndex % dst.length] = src[sampleIndex % src.length];
+        }
+      }
+      __privateSet(this, _buffer, next);
+      __privateSet(this, _readIndex, copyStart);
+      __privateMethod(this, _AudioRingBuffer_instances, pruneTimestampAnchors_fn).call(this);
+      __privateSet(this, _stalled, samplesToKeep === 0 || wasStalled && samplesToKeep < __privateMethod(this, _AudioRingBuffer_instances, refillFrames_fn).call(this));
+      if (!__privateGet(this, _stalled)) __privateSet(this, _hasStarted, true);
+    }
+    getDiagAndReset() {
+      if (!__privateGet(this, _diagEnabled) || __privateGet(this, _diagReads) === 0) return null;
+      const result = {
+        reads: __privateGet(this, _diagReads),
+        avgFill: Math.round(__privateGet(this, _diagFillSum) / __privateGet(this, _diagReads)),
+        capacity: this.capacity,
+        skips: 0,
+        dups: 0,
+        overflowSamples: __privateGet(this, _diagOverflowSamples)
+      };
+      __privateSet(this, _diagReads, 0);
+      __privateSet(this, _diagFillSum, 0);
+      __privateSet(this, _diagOverflowSamples, 0);
+      return result;
+    }
+  };
+  _buffer = new WeakMap();
+  _writeIndex = new WeakMap();
+  _readIndex = new WeakMap();
+  _stalled = new WeakMap();
+  _startupFrames = new WeakMap();
+  _resumeFrames = new WeakMap();
+  _resumeFollowsStartup = new WeakMap();
+  _hasStarted = new WeakMap();
+  _capacityHeadroomFrames = new WeakMap();
+  _timestampAnchors = new WeakMap();
+  _diagEnabled = new WeakMap();
+  _diagReads = new WeakMap();
+  _diagFillSum = new WeakMap();
+  _diagOverflowSamples = new WeakMap();
+  _AudioRingBuffer_instances = new WeakSet();
+  pruneTimestampAnchors_fn = function() {
+    let keep = 0;
+    while (keep + 1 < __privateGet(this, _timestampAnchors).length && __privateGet(this, _timestampAnchors)[keep + 1].sampleIndex <= __privateGet(this, _readIndex)) {
+      keep++;
+    }
+    if (keep > 0) __privateGet(this, _timestampAnchors).splice(0, keep);
+  };
+  refillFrames_fn = function() {
+    return __privateGet(this, _hasStarted) ? __privateGet(this, _resumeFrames) : __privateGet(this, _startupFrames);
+  };
+
+  // src/audio/render-worklet.ts
+  var _buffer2, _underflow, _diagUnderflow, _started, _stateCounter, _diagEnabled2, _diagCounter, _generation, _writtenFrames, _heldUntilStart, _resumeAfterReset, _Render_instances, flushDiag_fn;
+  var Render = class extends AudioWorkletProcessor {
+    constructor() {
+      super();
+      __privateAdd(this, _Render_instances);
+      __privateAdd(this, _buffer2);
+      __privateAdd(this, _underflow, 0);
+      __privateAdd(this, _diagUnderflow, 0);
+      __privateAdd(this, _started, false);
+      __privateAdd(this, _stateCounter, 0);
+      __privateAdd(this, _diagEnabled2, false);
+      __privateAdd(this, _diagCounter, 0);
+      __privateAdd(this, _generation, 0);
+      __privateAdd(this, _writtenFrames, 0);
+      __privateAdd(this, _heldUntilStart, false);
+      __privateAdd(this, _resumeAfterReset, false);
+      this.port.onmessage = (event) => {
+        const msg = event.data;
+        if (msg.type === "init") {
+          const heldUntilStart = msg.holdUntilStart ?? false;
+          const latencyFrames = Math.ceil(msg.rate * (msg.latencyMs / 1e3));
+          const startupFrames = msg.startupFrames ?? latencyFrames;
+          const capacityFrames = msg.capacityFrames ?? Math.max(latencyFrames, startupFrames) + latencyFrames;
+          if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {
+            throw new Error("invalid startup frames");
+          }
+          if (!Number.isSafeInteger(capacityFrames) || capacityFrames < startupFrames) {
+            throw new Error("invalid capacity frames");
+          }
+          __privateSet(this, _generation, msg.generation);
+          __privateSet(this, _buffer2, new AudioRingBuffer({
+            channels: msg.channels,
+            rate: msg.rate,
+            latencyMs: msg.latencyMs,
+            // The explicit start gate owns the one-time startup prefill. Once
+            // released, resume from an underrun as soon as new PCM is accepted.
+            startupFrames,
+            resumeFrames: heldUntilStart ? 1 : void 0,
+            capacityFrames,
+            startUnstalled: msg.startUnstalled,
+            warmupReads: msg.warmupReads,
+            diag: msg.diag ?? false
+          }));
+          __privateSet(this, _diagEnabled2, msg.diag ?? false);
+          __privateSet(this, _underflow, 0);
+          __privateSet(this, _diagUnderflow, 0);
+          __privateSet(this, _started, false);
+          __privateSet(this, _writtenFrames, 0);
+          __privateSet(this, _heldUntilStart, heldUntilStart);
+          __privateSet(this, _resumeAfterReset, heldUntilStart);
+        } else if (msg.type === "data") {
+          if (!__privateGet(this, _buffer2)) return;
+          __privateGet(this, _buffer2).write(msg.timestamp, msg.data);
+          __privateSet(this, _writtenFrames, __privateGet(this, _writtenFrames) + (msg.data[0]?.length ?? 0));
+          if (__privateGet(this, _heldUntilStart) || __privateGet(this, _diagEnabled2)) {
+            this.port.postMessage({
+              type: "writeAck",
+              generation: __privateGet(this, _generation),
+              bufferedFrames: __privateGet(this, _buffer2).length,
+              writtenFrames: __privateGet(this, _writtenFrames)
+            });
+          }
+        } else if (msg.type === "start") {
+          if (msg.generation === __privateGet(this, _generation)) __privateSet(this, _heldUntilStart, false);
+        } else if (msg.type === "latency") {
+          if (!__privateGet(this, _buffer2)) return;
+          __privateGet(this, _buffer2).resize(msg.latencyMs);
+        } else if (msg.type === "reset") {
+          __privateSet(this, _generation, msg.generation);
+          __privateGet(this, _buffer2)?.reset(msg.startUnstalled ?? false, __privateGet(this, _resumeAfterReset));
+          __privateSet(this, _underflow, 0);
+          __privateSet(this, _diagUnderflow, 0);
+          __privateSet(this, _started, false);
+          __privateSet(this, _writtenFrames, 0);
+          __privateSet(this, _heldUntilStart, false);
+        } else if (msg.type === "requestDiag") {
+          __privateMethod(this, _Render_instances, flushDiag_fn).call(this);
+        }
+      };
+    }
+    process(_inputs, outputs) {
+      const output = outputs[0];
+      const samplesRead = __privateGet(this, _heldUntilStart) ? 0 : __privateGet(this, _buffer2)?.read(output) ?? 0;
+      if (samplesRead > 0) __privateSet(this, _started, true);
+      if (samplesRead < output[0].length && __privateGet(this, _started)) {
+        const missing = output[0].length - samplesRead;
+        __privateSet(this, _underflow, __privateGet(this, _underflow) + missing);
+        __privateSet(this, _diagUnderflow, __privateGet(this, _diagUnderflow) + missing);
+      } else if (__privateGet(this, _underflow) > 0 && __privateGet(this, _buffer2)) {
+        console.warn(`audio underflow: ${Math.round(1e3 * __privateGet(this, _underflow) / __privateGet(this, _buffer2).rate)}ms`);
+        __privateSet(this, _underflow, 0);
+      }
+      __privateWrapper(this, _stateCounter)._++;
+      if (__privateGet(this, _buffer2) && __privateGet(this, _stateCounter) >= 5) {
+        __privateSet(this, _stateCounter, 0);
+        const msg = {
+          type: "state",
+          generation: __privateGet(this, _generation),
+          timestamp: __privateGet(this, _heldUntilStart) ? void 0 : __privateGet(this, _buffer2).timestampUs,
+          stalled: __privateGet(this, _heldUntilStart) || __privateGet(this, _buffer2).stalled,
+          bufferedFrames: __privateGet(this, _buffer2).length,
+          writtenFrames: __privateGet(this, _writtenFrames)
+        };
+        this.port.postMessage(msg);
+      }
+      if (__privateGet(this, _diagEnabled2) && __privateGet(this, _buffer2)) {
+        __privateWrapper(this, _diagCounter)._++;
+        if (__privateGet(this, _diagCounter) >= 375) {
+          __privateSet(this, _diagCounter, 0);
+          __privateMethod(this, _Render_instances, flushDiag_fn).call(this);
+        }
+      }
+      return true;
+    }
+  };
+  _buffer2 = new WeakMap();
+  _underflow = new WeakMap();
+  _diagUnderflow = new WeakMap();
+  _started = new WeakMap();
+  _stateCounter = new WeakMap();
+  _diagEnabled2 = new WeakMap();
+  _diagCounter = new WeakMap();
+  _generation = new WeakMap();
+  _writtenFrames = new WeakMap();
+  _heldUntilStart = new WeakMap();
+  _resumeAfterReset = new WeakMap();
+  _Render_instances = new WeakSet();
+  flushDiag_fn = function() {
+    if (!__privateGet(this, _buffer2)) return;
+    const d = __privateGet(this, _buffer2).getDiagAndReset();
+    if (!d && __privateGet(this, _diagUnderflow) === 0) return;
+    const msg = {
+      type: "ringBufDiag",
+      generation: __privateGet(this, _generation),
+      reads: d?.reads ?? 0,
+      avgFill: d?.avgFill ?? 0,
+      capacity: d?.capacity ?? __privateGet(this, _buffer2).capacity,
+      skipsPerSec: d?.skips ?? 0,
+      dupsPerSec: d?.dups ?? 0,
+      overflowSamplesPerSec: d?.overflowSamples ?? 0,
+      underflowSamplesPerSec: __privateGet(this, _diagUnderflow)
+    };
+    __privateSet(this, _diagUnderflow, 0);
+    this.port.postMessage(msg);
+  };
+  registerProcessor("mmt-render", Render);
+})();
+//# sourceMappingURL=render-worklet.js.map

package/dist/worklet/render-worklet.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/audio/audio-ring-buffer.ts", "../../src/audio/render-worklet.ts"],
+  "sourcesContent": ["/**\n * Timestamp-anchored FIFO shared by MMT AudioWorklet consumers.\n *\n * PCM remains in decoder emission order. Media timestamps are exact anchors\n * for playout reporting only; they never reposition samples or trigger a\n * guessed discontinuity. The FIFO starts after its full catalog-derived\n * latency is buffered and performs no sample skip/dup clock recovery.\n */\n\nexport interface AudioRingBufferConfig {\n  channels: number\n  rate: number\n  latencyMs: number\n  /** Exact PCM startup threshold. Overrides latencyMs when provided. */\n  startupFrames?: number\n  /** PCM refill threshold after the first underrun. Defaults to startupFrames. */\n  resumeFrames?: number\n  /** Exact PCM storage ceiling. Must cover the startup and resume thresholds. */\n  capacityFrames?: number\n  startUnstalled?: boolean\n  /** Deprecated compatibility input. Clock recovery is not performed. */\n  warmupReads?: number\n  diag?: boolean\n}\n\nexport interface AudioRingBufferDiag {\n  reads: number\n  avgFill: number\n  capacity: number\n  skips: number\n  dups: number\n  overflowSamples: number\n}\n\ntype TimestampAnchor = {\n  sampleIndex: number\n  timestampUs: number\n}\n\nexport class AudioRingBuffer {\n  readonly channels: number\n  readonly rate: number\n\n  #buffer: Float32Array[]\n  #writeIndex = 0\n  #readIndex = 0\n  #stalled: boolean\n  #startupFrames: number\n  #resumeFrames: number\n  #resumeFollowsStartup: boolean\n  #hasStarted: boolean\n  #capacityHeadroomFrames: number\n  #timestampAnchors: TimestampAnchor[] = []\n\n  #diagEnabled: boolean\n  #diagReads = 0\n  #diagFillSum = 0\n  #diagOverflowSamples = 0\n\n  constructor(config: AudioRingBufferConfig) {\n    if (!Number.isInteger(config.channels) || config.channels <= 0) {\n      throw new Error('invalid channels')\n    }\n    if (!Number.isFinite(config.rate) || config.rate <= 0) {\n      throw new Error('invalid sample rate')\n    }\n    if (!Number.isFinite(config.latencyMs) || config.latencyMs <= 0) {\n      throw new Error('invalid latency')\n    }\n\n    const latencyFrames = Math.ceil(config.rate * (config.latencyMs / 1000))\n    const startupFrames = config.startupFrames ?? latencyFrames\n    const resumeFrames = config.resumeFrames ?? startupFrames\n    const thresholdFrames = Math.max(startupFrames, resumeFrames)\n    const capacityFrames = config.capacityFrames ?? Math.max(latencyFrames, thresholdFrames)\n    if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {\n      throw new Error('invalid startup frames')\n    }\n    if (!Number.isSafeInteger(resumeFrames) || resumeFrames <= 0) {\n      throw new Error('invalid resume frames')\n    }\n    if (!Number.isSafeInteger(capacityFrames) || capacityFrames < thresholdFrames) {\n      throw new Error('invalid capacity frames')\n    }\n\n    this.channels = config.channels\n    this.rate = config.rate\n    this.#startupFrames = startupFrames\n    this.#resumeFrames = resumeFrames\n    this.#resumeFollowsStartup = config.resumeFrames === undefined\n    this.#hasStarted = config.startUnstalled ?? false\n    this.#capacityHeadroomFrames = capacityFrames - thresholdFrames\n    this.#stalled = !(config.startUnstalled ?? false)\n    this.#diagEnabled = config.diag ?? false\n    this.#buffer = Array.from(\n      { length: config.channels },\n      () => new Float32Array(capacityFrames),\n    )\n  }\n\n  get stalled(): boolean { return this.#stalled }\n  get startupFrames(): number { return this.#startupFrames }\n  get capacity(): number { return this.#buffer[0].length }\n  get length(): number { return this.#writeIndex - this.#readIndex }\n\n  /** Timestamp of the next media sample after the PCM already emitted. */\n  get timestampUs(): number | undefined {\n    const anchor = this.#timestampAnchors[0]\n    if (!anchor || anchor.sampleIndex > this.#readIndex) return undefined\n    return anchor.timestampUs + ((this.#readIndex - anchor.sampleIndex) / this.rate) * 1_000_000\n  }\n\n  write(timestampUs: number, data: Float32Array[]): void {\n    if (data.length !== this.channels) throw new Error('wrong channel count')\n    if (!Number.isFinite(timestampUs)) throw new Error('invalid timestamp')\n    const samples = data[0].length\n    if (samples === 0) return\n    if (data.some((channel) => channel.length !== samples)) {\n      throw new Error('mismatched channel lengths')\n    }\n\n    const start = this.#writeIndex\n    const end = start + samples\n    this.#timestampAnchors.push({ sampleIndex: start, timestampUs })\n\n    const overflow = end - this.#readIndex - this.capacity\n    if (overflow > 0) {\n      this.#stalled = false\n      this.#hasStarted = true\n      this.#readIndex += overflow\n      if (this.#diagEnabled) this.#diagOverflowSamples += overflow\n      this.#pruneTimestampAnchors()\n    }\n\n    const refillFrames = this.#hasStarted ? this.#resumeFrames : this.#startupFrames\n    if (this.#stalled && end - this.#readIndex >= refillFrames) {\n      this.#stalled = false\n      this.#hasStarted = true\n    }\n\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = data[channel]\n      const dst = this.#buffer[channel]\n      for (let i = 0; i < samples; i++) {\n        dst[(start + i) % dst.length] = src[i]\n      }\n    }\n    this.#writeIndex = end\n  }\n\n  read(output: Float32Array[]): number {\n    if (output.length !== this.channels) throw new Error('wrong channel count')\n    if (this.#stalled) return 0\n\n    const available = this.length\n    if (available === 0) {\n      this.#stalled = true\n      return 0\n    }\n\n    const requested = output[0].length\n    const readSamples = Math.min(available, requested)\n\n    for (let channel = 0; channel < this.channels; channel++) {\n      const dst = output[channel]\n      const src = this.#buffer[channel]\n      for (let i = 0; i < readSamples; i++) {\n        dst[i] = src[(this.#readIndex + i) % src.length]\n      }\n      for (let i = readSamples; i < requested; i++) dst[i] = 0\n    }\n\n    this.#readIndex += readSamples\n    this.#pruneTimestampAnchors()\n    if (readSamples < requested) this.#stalled = true\n\n    if (this.#diagEnabled) {\n      this.#diagReads++\n      this.#diagFillSum += available\n    }\n    return readSamples\n  }\n\n  /** Clear queued PCM; optionally treat the next fill as post-start recovery. */\n  reset(startUnstalled = false, resumeAfterReset = false): void {\n    this.#writeIndex = 0\n    this.#readIndex = 0\n    this.#stalled = !startUnstalled\n    this.#hasStarted = startUnstalled || resumeAfterReset\n    this.#timestampAnchors = []\n    this.#diagReads = 0\n    this.#diagFillSum = 0\n    this.#diagOverflowSamples = 0\n  }\n\n  /**\n   * Change the startup latency while preserving the configured storage\n   * headroom above its buffering thresholds. Active playout keeps draining\n   * retained PCM; a stalled buffer waits for its startup or resume threshold.\n   */\n  resize(latencyMs: number): void {\n    if (!Number.isFinite(latencyMs) || latencyMs <= 0) {\n      throw new Error('invalid latency')\n    }\n    const newStartupFrames = Math.ceil(this.rate * (latencyMs / 1000))\n    if (!Number.isSafeInteger(newStartupFrames) || newStartupFrames <= 0) {\n      throw new Error('invalid latency')\n    }\n    const newResumeFrames = this.#resumeFollowsStartup ? newStartupFrames : this.#resumeFrames\n    const newCapacity =\n      Math.max(newStartupFrames, newResumeFrames) + this.#capacityHeadroomFrames\n    if (\n      !Number.isSafeInteger(newCapacity) ||\n      newCapacity < Math.max(newStartupFrames, newResumeFrames)\n    ) {\n      throw new Error('invalid capacity frames')\n    }\n    const wasStalled = this.#stalled\n    this.#startupFrames = newStartupFrames\n    this.#resumeFrames = newResumeFrames\n    if (newCapacity === this.capacity) {\n      if (wasStalled && this.length >= this.#refillFrames()) {\n        this.#stalled = false\n        this.#hasStarted = true\n      }\n      return\n    }\n\n    const next = Array.from(\n      { length: this.channels },\n      () => new Float32Array(newCapacity),\n    )\n    const samplesToKeep = Math.min(this.length, newCapacity)\n    const copyStart = this.#writeIndex - samplesToKeep\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = this.#buffer[channel]\n      const dst = next[channel]\n      for (let i = 0; i < samplesToKeep; i++) {\n        const sampleIndex = copyStart + i\n        dst[sampleIndex % dst.length] = src[sampleIndex % src.length]\n      }\n    }\n\n    this.#buffer = next\n    this.#readIndex = copyStart\n    this.#pruneTimestampAnchors()\n    this.#stalled = samplesToKeep === 0 || (wasStalled && samplesToKeep < this.#refillFrames())\n    if (!this.#stalled) this.#hasStarted = true\n  }\n\n  getDiagAndReset(): AudioRingBufferDiag | null {\n    if (!this.#diagEnabled || this.#diagReads === 0) return null\n    const result: AudioRingBufferDiag = {\n      reads: this.#diagReads,\n      avgFill: Math.round(this.#diagFillSum / this.#diagReads),\n      capacity: this.capacity,\n      skips: 0,\n      dups: 0,\n      overflowSamples: this.#diagOverflowSamples,\n    }\n    this.#diagReads = 0\n    this.#diagFillSum = 0\n    this.#diagOverflowSamples = 0\n    return result\n  }\n\n  #pruneTimestampAnchors(): void {\n    let keep = 0\n    while (\n      keep + 1 < this.#timestampAnchors.length &&\n      this.#timestampAnchors[keep + 1].sampleIndex <= this.#readIndex\n    ) {\n      keep++\n    }\n    if (keep > 0) this.#timestampAnchors.splice(0, keep)\n  }\n\n  #refillFrames(): number {\n    return this.#hasStarted ? this.#resumeFrames : this.#startupFrames\n  }\n}\n", "/**\n * Shared AudioWorklet render processor.\n *\n * This file is bundled into a self-contained IIFE at build time\n * (dist/worklet/render-worklet.js) because AudioWorkletGlobalScope cannot\n * resolve bare specifiers. The AudioRingBuffer dependency is inlined at\n * bundle time; do not import from @blockcast packages at runtime.\n *\n * Consumers load the prebuilt bundle via audioWorklet.addModule(url) where\n * url is obtained from `@blockcast/mmt-render/audio/worklet-url`.\n */\n\nimport { AudioRingBuffer } from './audio-ring-buffer.js'\nimport type { FromMain, ToMain } from './render-messages.js'\n\nclass Render extends AudioWorkletProcessor {\n  #buffer?: AudioRingBuffer\n  #underflow = 0\n  #diagUnderflow = 0\n  #started = false\n  #stateCounter = 0\n  #diagEnabled = false\n  #diagCounter = 0\n  #generation = 0\n  #writtenFrames = 0\n  #heldUntilStart = false\n  #resumeAfterReset = false\n\n  constructor() {\n    super()\n    this.port.onmessage = (event: MessageEvent<FromMain>) => {\n      const msg = event.data\n      if (msg.type === 'init') {\n        const heldUntilStart = msg.holdUntilStart ?? false\n        const latencyFrames = Math.ceil(msg.rate * (msg.latencyMs / 1000))\n        const startupFrames = msg.startupFrames ?? latencyFrames\n        // Keep one latency window above the release threshold so PCM accepted\n        // during the writeAck -> start round trip cannot evict the prefill head.\n        const capacityFrames =\n          msg.capacityFrames ?? Math.max(latencyFrames, startupFrames) + latencyFrames\n        if (!Number.isSafeInteger(startupFrames) || startupFrames <= 0) {\n          throw new Error('invalid startup frames')\n        }\n        if (!Number.isSafeInteger(capacityFrames) || capacityFrames < startupFrames) {\n          throw new Error('invalid capacity frames')\n        }\n        this.#generation = msg.generation\n        this.#buffer = new AudioRingBuffer({\n          channels: msg.channels,\n          rate: msg.rate,\n          latencyMs: msg.latencyMs,\n          // The explicit start gate owns the one-time startup prefill. Once\n          // released, resume from an underrun as soon as new PCM is accepted.\n          startupFrames,\n          resumeFrames: heldUntilStart ? 1 : undefined,\n          capacityFrames,\n          startUnstalled: msg.startUnstalled,\n          warmupReads: msg.warmupReads,\n          diag: msg.diag ?? false,\n        })\n        this.#diagEnabled = msg.diag ?? false\n        this.#underflow = 0\n        this.#diagUnderflow = 0\n        this.#started = false\n        this.#writtenFrames = 0\n        this.#heldUntilStart = heldUntilStart\n        this.#resumeAfterReset = heldUntilStart\n      } else if (msg.type === 'data') {\n        if (!this.#buffer) return\n        this.#buffer.write(msg.timestamp, msg.data)\n        this.#writtenFrames += msg.data[0]?.length ?? 0\n        if (this.#heldUntilStart || this.#diagEnabled) {\n          this.port.postMessage({\n            type: 'writeAck',\n            generation: this.#generation,\n            bufferedFrames: this.#buffer.length,\n            writtenFrames: this.#writtenFrames,\n          })\n        }\n      } else if (msg.type === 'start') {\n        if (msg.generation === this.#generation) this.#heldUntilStart = false\n      } else if (msg.type === 'latency') {\n        if (!this.#buffer) return\n        this.#buffer.resize(msg.latencyMs)\n      } else if (msg.type === 'reset') {\n        this.#generation = msg.generation\n        this.#buffer?.reset(msg.startUnstalled ?? false, this.#resumeAfterReset)\n        this.#underflow = 0\n        this.#diagUnderflow = 0\n        this.#started = false\n        this.#writtenFrames = 0\n        this.#heldUntilStart = false\n      } else if (msg.type === 'requestDiag') {\n        this.#flushDiag()\n      }\n    }\n  }\n\n  process(_inputs: Float32Array[][], outputs: Float32Array[][]): boolean {\n    const output = outputs[0]\n    const samplesRead = this.#heldUntilStart ? 0 : (this.#buffer?.read(output) ?? 0)\n\n    if (samplesRead > 0) this.#started = true\n    if (samplesRead < output[0].length && this.#started) {\n      const missing = output[0].length - samplesRead\n      this.#underflow += missing\n      this.#diagUnderflow += missing\n    } else if (this.#underflow > 0 && this.#buffer) {\n      // eslint-disable-next-line no-console\n      console.warn(`audio underflow: ${Math.round((1000 * this.#underflow) / this.#buffer.rate)}ms`)\n      this.#underflow = 0\n    }\n\n    // State update ~60/sec (every 5 processes at 128-sample quantum @ 48kHz \u2248 2.67ms each)\n    this.#stateCounter++\n    if (this.#buffer && this.#stateCounter >= 5) {\n      this.#stateCounter = 0\n      const msg: ToMain = {\n        type: 'state',\n        generation: this.#generation,\n        timestamp: this.#heldUntilStart ? undefined : this.#buffer.timestampUs,\n        stalled: this.#heldUntilStart || this.#buffer.stalled,\n        bufferedFrames: this.#buffer.length,\n        writtenFrames: this.#writtenFrames,\n      }\n      this.port.postMessage(msg)\n    }\n\n    // Diag telemetry every ~1s if enabled.\n    if (this.#diagEnabled && this.#buffer) {\n      this.#diagCounter++\n      if (this.#diagCounter >= 375) {\n        this.#diagCounter = 0\n        this.#flushDiag()\n      }\n    }\n\n    return true\n  }\n\n  #flushDiag(): void {\n    if (!this.#buffer) return\n    const d = this.#buffer.getDiagAndReset()\n    if (!d && this.#diagUnderflow === 0) return\n    const msg: ToMain = {\n      type: 'ringBufDiag',\n      generation: this.#generation,\n      reads: d?.reads ?? 0,\n      avgFill: d?.avgFill ?? 0,\n      capacity: d?.capacity ?? this.#buffer.capacity,\n      skipsPerSec: d?.skips ?? 0,\n      dupsPerSec: d?.dups ?? 0,\n      overflowSamplesPerSec: d?.overflowSamples ?? 0,\n      underflowSamplesPerSec: this.#diagUnderflow,\n    }\n    this.#diagUnderflow = 0\n    this.port.postMessage(msg)\n  }\n}\n\nregisterProcessor('mmt-render', Render)\n"],
+  "mappings": "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",
+  "names": ["_buffer", "_diagEnabled"]
+}

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@blockcast/mmt-render",
+  "version": "0.1.0-main.c0e9e40265a1",
+  "description": "Shared MMT render pipeline (FEC-aware pacing, interleave timing, audio worklet) for MoQ players",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./pacing": {
+      "import": "./dist/pacing/index.js",
+      "types": "./dist/pacing/index.d.ts"
+    },
+    "./pacing/frame-pacer": {
+      "import": "./dist/pacing/frame-pacer.js",
+      "types": "./dist/pacing/frame-pacer.d.ts"
+    },
+    "./pacing/interleave-timing": {
+      "import": "./dist/pacing/interleave-timing.js",
+      "types": "./dist/pacing/interleave-timing.d.ts"
+    },
+    "./audio": {
+      "import": "./dist/audio/index.js",
+      "types": "./dist/audio/index.d.ts"
+    },
+    "./audio/ring-buffer": {
+      "import": "./dist/audio/audio-ring-buffer.js",
+      "types": "./dist/audio/audio-ring-buffer.d.ts"
+    },
+    "./audio/render-messages": {
+      "import": "./dist/audio/render-messages.js",
+      "types": "./dist/audio/render-messages.d.ts"
+    },
+    "./audio/render-pipeline": {
+      "import": "./dist/audio/audio-render-pipeline.js",
+      "types": "./dist/audio/audio-render-pipeline.d.ts"
+    },
+    "./audio/worklet-url": {
+      "import": "./dist/audio/worklet-url.js",
+      "types": "./dist/audio/worklet-url.d.ts"
+    },
+    "./audio/worklet.js": "./dist/worklet/render-worklet.js",
+    "./video": {
+      "import": "./dist/video/index.js",
+      "types": "./dist/video/index.d.ts"
+    },
+    "./video/keyframe-gate": {
+      "import": "./dist/video/keyframe-gate.js",
+      "types": "./dist/video/keyframe-gate.d.ts"
+    },
+    "./video/render-pipeline": {
+      "import": "./dist/video/video-render-pipeline.js",
+      "types": "./dist/video/video-render-pipeline.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/__tests__",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "scripts": {
+    "build": "tsc --emitDeclarationOnly && node build.mjs",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@blockcast/mmt-container": "0.1.0-main.c0e9e40265a1",
+    "@blockcast/mmt-fec": "0.1.0-main.c0e9e40265a1"
+  },
+  "devDependencies": {
+    "@types/audioworklet": "^0.0.77",
+    "esbuild": "^0.28.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "keywords": [
+    "mmt",
+    "mmtp",
+    "render",
+    "audio-worklet",
+    "pacing",
+    "fec",
+    "interleave",
+    "moq"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Blockcast/libmmt.git",
+    "directory": "packages/mmt-render"
+  }
+}

package/src/audio/audio-buffer-plan.ts

@@ -0,0 +1,62 @@
+export interface AudioBurstBufferPlanInput {
+  sampleRate: number
+  chunkFrames: number
+  /** Catalog media-group duration. Integer milliseconds may be rounded. */
+  groupDurationMs: number
+  /** Optional catalog-derived datagram/FEC delivery span. */
+  deliveryWindowMs?: number
+}
+
+export interface AudioBurstBufferPlan {
+  /** PCM required before playout starts or resumes. */
+  startupFrames: number
+  /** Maximum retained PCM, including the next complete delivery burst. */
+  capacityFrames: number
+  /** Maximum PCM frames delivered as one catalog-defined burst. */
+  deliveryFrames: number
+}
+
+function positive(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`invalid ${label}`)
+  return value
+}
+
+/**
+ * Convert catalog delivery timing into exact codec-frame FIFO geometry.
+ *
+ * `groupDurationMs` is commonly rounded to an integer, so media-group units
+ * use nearest-unit rounding. FEC delivery windows are upper bounds and use
+ * ceiling. Storage holds the startup burst plus one complete successor burst;
+ * this prevents an atomic MoQ group from overwriting PCM while the worklet is
+ * draining the preceding group without adding a guessed time margin.
+ */
+export function deriveAudioBurstBufferPlan(
+  input: AudioBurstBufferPlanInput,
+): AudioBurstBufferPlan {
+  const sampleRate = positive(input.sampleRate, 'sample rate')
+  const chunkFrames = positive(input.chunkFrames, 'audio chunk size')
+  const groupDurationMs = positive(input.groupDurationMs, 'audio group duration')
+  if (!Number.isInteger(chunkFrames)) throw new Error('invalid audio chunk size')
+
+  const chunkDurationMs = (1000 * chunkFrames) / sampleRate
+  const groupChunks = Math.max(1, Math.round(groupDurationMs / chunkDurationMs))
+  const deliveryWindowChunks =
+    input.deliveryWindowMs === undefined
+      ? 0
+      : Math.max(
+          1,
+          Math.ceil(positive(input.deliveryWindowMs, 'audio delivery window') / chunkDurationMs),
+        )
+  const deliveryChunks = Math.max(groupChunks, deliveryWindowChunks)
+  const deliveryFrames = deliveryChunks * chunkFrames
+  const capacityFrames = deliveryFrames + deliveryFrames
+  if (!Number.isSafeInteger(deliveryFrames) || !Number.isSafeInteger(capacityFrames)) {
+    throw new Error('audio buffer frame count exceeds safe integer range')
+  }
+
+  return {
+    startupFrames: deliveryFrames,
+    capacityFrames,
+    deliveryFrames,
+  }
+}