@taole/giftstage 0.1.34 → 0.1.36

package/dist/assets/webcodecs-mp4.worker-DeS4ARzq.js

@@ -0,0 +1,398 @@
+let w = null;
+function x() {
+  return w || (w = import("./mp4box.all-Bcqr6y1c.js").catch((o) => {
+    throw w = null, o;
+  })), w;
+}
+var k = Object.defineProperty, D = (o, e, t) => e in o ? k(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t, u = (o, e, t) => D(o, typeof e != "symbol" ? e + "" : e, t);
+const P = 800;
+function M(o) {
+  return o.startsWith("avc1") || o.startsWith("avc3");
+}
+function F(o) {
+  const e = new Uint8Array(o);
+  if (e.byteLength < 8) return o;
+  const t = e[4], r = e[5], s = e[6], i = e[7];
+  return t === 97 && r === 118 && s === 99 && i === 67 ? o.slice(8) : o;
+}
+async function C(o) {
+  const e = o.avcC;
+  if (!e) return;
+  const { DataStream: t } = await x(), r = new t();
+  e.write(r);
+  const s = r.byteLength;
+  if (s <= 0) return;
+  const i = r.buffer.slice(0, s);
+  return F(i);
+}
+async function E(o) {
+  const { createFile: e } = await x();
+  return new Promise((t, r) => {
+    const s = e(), i = o.slice(0);
+    i.fileStart = 0, s.onError = (n) => {
+      r(new Error(`mp4box: ${n}`));
+    }, s.onReady = (n) => {
+      var d, c, l, h, f, y, m;
+      const a = (d = n.videoTracks) == null ? void 0 : d[0];
+      if (!a) {
+        r(new Error("mp4box: no video track"));
+        return;
+      }
+      if (!M(a.codec)) {
+        r(new Error(`mp4box: unsupported video codec ${a.codec}`));
+        return;
+      }
+      if (a.nb_samples > P) {
+        r(new Error(`mp4box: too many samples (${a.nb_samples})`));
+        return;
+      }
+      const g = [];
+      s.onSamples = (z, Q, S) => {
+        g.push(...S);
+      }, s.setExtractionOptions(a.id, null, {
+        nbSamples: Math.max(a.nb_samples, 1)
+      }), s.start();
+      const v = a.timescale > 0 ? a.duration / a.timescale : n.duration / (n.timescale || 1);
+      if (g.length === 0) {
+        r(new Error("mp4box: extraction produced no samples"));
+        return;
+      }
+      t({
+        codec: a.codec,
+        timescale: a.timescale,
+        durationSec: Number.isFinite(v) ? v : 0,
+        videoWidth: (h = (l = (c = a.video) == null ? void 0 : c.width) != null ? l : a.track_width) != null ? h : 0,
+        videoHeight: (m = (y = (f = a.video) == null ? void 0 : f.height) != null ? y : a.track_height) != null ? m : 0,
+        samples: g
+      });
+    }, s.appendBuffer(i), s.flush();
+  });
+}
+const _ = 25e3;
+async function I(o, e, t) {
+  const r = performance.now();
+  let s = 0;
+  for (; o.decodeQueueSize > 0; )
+    if (await new Promise((i) => queueMicrotask(i)), s++, s % 120 === 0 && await new Promise((i) => setTimeout(i, 0)), performance.now() - r > t) {
+      console.warn("[GiftStage:WC] decodeQueue drain gave up", {
+        label: e,
+        decodeQueueSize: o.decodeQueueSize,
+        spins: s
+      });
+      break;
+    }
+}
+async function N(o, e) {
+  console.info("[GiftStage:WC] VideoDecoder.flush…", e);
+  try {
+    await Promise.race([
+      o.flush(),
+      new Promise((t, r) => {
+        setTimeout(
+          () => r(
+            new Error(
+              `VideoDecoder.flush() timed out after ${_}ms (${JSON.stringify(e)})`
+            )
+          ),
+          _
+        );
+      })
+    ]);
+  } catch (t) {
+    try {
+      o.close();
+    } catch (r) {
+    }
+    throw t;
+  }
+}
+class T {
+  constructor(e, t, r, s, i, n, d, c) {
+    this.decodeOrder = e, this.presTimes = t, this.timescale = r, this.codec = s, this.description = i, this.duration = n, this.callbacks = d, u(this, "decoder", null), u(this, "nextChunk", 0), u(this, "chunksFed", 0), u(this, "targetNeedIdx"), u(this, "lastPostedMax", -1), u(this, "minPosted", Number.POSITIVE_INFINITY), u(this, "playbackNeedFloor"), u(this, "freeSlots", 0), u(this, "eosClosed", !1), u(this, "pumpScheduled", !1), u(this, "pumping", !1), u(this, "destroyed", !1), u(this, "onDecoderDequeue", () => this.schedulePump()), this.targetNeedIdx = c, this.playbackNeedFloor = b(t, n, 0), this.freeSlots = Math.max(1, c - this.playbackNeedFloor + 1), this.schedulePump();
+  }
+  /** Raise the decode target and/or update main-thread ring headroom; resumes the pump if idle. */
+  ensure(e, t) {
+    this.destroyed || (this.targetNeedIdx = Math.max(this.targetNeedIdx, e), this.freeSlots = Math.max(0, t), this.schedulePump());
+  }
+  /** Restart decode from the nearest keyframe at/before t=0 (backward seek / loop wrap). */
+  rewind() {
+    this.destroyed || this.doRewind();
+  }
+  destroy() {
+    var e, t;
+    if (this.destroyed = !0, this.decoder && this.decoder.state !== "closed") {
+      (t = (e = this.decoder).removeEventListener) == null || t.call(e, "dequeue", this.onDecoderDequeue);
+      try {
+        this.decoder.close();
+      } catch (r) {
+      }
+    }
+    this.decoder = null;
+  }
+  schedulePump() {
+    this.pumpScheduled || this.destroyed || (this.pumpScheduled = !0, queueMicrotask(() => {
+      this.pumpScheduled = !1, this.runPump();
+    }));
+  }
+  async doRewind() {
+    var e, t;
+    if (this.decoder && this.decoder.state !== "closed") {
+      (t = (e = this.decoder).removeEventListener) == null || t.call(e, "dequeue", this.onDecoderDequeue);
+      try {
+        this.decoder.close();
+      } catch (s) {
+      }
+    }
+    this.decoder = null, this.nextChunk = V(this.decodeOrder), this.chunksFed = 0, this.lastPostedMax = -1, this.minPosted = Number.POSITIVE_INFINITY, this.eosClosed = !1;
+    const r = b(this.presTimes, this.duration, 0);
+    this.playbackNeedFloor = r, this.targetNeedIdx = Math.max(
+      this.targetNeedIdx,
+      Math.min(this.presTimes.length - 1, Math.max(0, r))
+    ), this.freeSlots = 1, this.schedulePump();
+  }
+  async openDecoder() {
+    var e;
+    if (this.decoder && this.decoder.state !== "closed") return;
+    const t = await A(this.codec, this.description), r = new VideoDecoder({
+      output: (s) => {
+        var i, n, d, c;
+        if ((n = (i = this.callbacks).onDecoded) == null || n.call(i), this.destroyed) {
+          try {
+            s.close();
+          } catch (f) {
+          }
+          return;
+        }
+        const l = W(this.presTimes, s.timestamp), h = Number.isFinite(this.minPosted) && this.minPosted <= this.playbackNeedFloor;
+        if (this.freeSlots <= 0 && h) {
+          try {
+            s.close();
+          } catch (f) {
+          }
+          (c = (d = this.callbacks).onDropped) == null || c.call(d), this.schedulePump();
+          return;
+        }
+        this.lastPostedMax = Math.max(this.lastPostedMax, l), this.minPosted = Math.min(this.minPosted, l), this.freeSlots > 0 && this.freeSlots--, this.callbacks.onFrame(l, s), this.schedulePump();
+      },
+      error: (s) => {
+        this.callbacks.onError ? this.callbacks.onError(s) : console.error("[GiftStage:WC] IncrementalH264Decoder VideoDecoder error", s);
+      }
+    });
+    r.configure(t), (e = r.addEventListener) == null || e.call(r, "dequeue", this.onDecoderDequeue), this.decoder = r;
+  }
+  feedOneChunk() {
+    var e, t;
+    const r = this.decoder, s = this.nextChunk;
+    if (s >= this.decodeOrder.length) return;
+    const i = this.decodeOrder[s];
+    this.nextChunk = s + 1;
+    const n = i.data;
+    if (!n || n.byteLength === 0) return;
+    const d = (t = (e = i.cts) != null ? e : i.dts) != null ? t : 0, c = Math.round(d / this.timescale * 1e6), l = i.duration && this.timescale > 0 ? Math.round(i.duration / this.timescale * 1e6) : void 0, h = new Uint8Array(n.byteLength);
+    h.set(n);
+    const f = new EncodedVideoChunk({
+      type: i.is_sync ? "key" : "delta",
+      timestamp: c,
+      duration: l,
+      data: h
+    });
+    r.decode(f), this.chunksFed++;
+  }
+  async finalizeEos() {
+    var e, t, r;
+    if (!this.decoder || this.eosClosed) return;
+    const s = this.decoder;
+    await I(s, "before flush", 1e4);
+    const i = s.decodeQueueSize;
+    await N(s, {
+      chunksDecoded: this.chunksFed,
+      outputsBeforeFlush: this.lastPostedMax + 1,
+      queueBeforeFlush: i
+    });
+    try {
+      (e = s.removeEventListener) == null || e.call(s, "dequeue", this.onDecoderDequeue), s.close();
+    } catch (n) {
+    }
+    this.decoder = null, this.eosClosed = !0, (r = (t = this.callbacks).onEos) == null || r.call(t);
+  }
+  async runPump() {
+    if (!(this.destroyed || this.pumping)) {
+      this.pumping = !0;
+      try {
+        for (; !this.destroyed; ) {
+          if (this.eosClosed) return;
+          const e = this.nextChunk < this.decodeOrder.length, t = Number.isFinite(this.minPosted) && this.minPosted <= this.playbackNeedFloor;
+          if (!e && !this.eosClosed) {
+            await this.finalizeEos();
+            continue;
+          }
+          if (this.lastPostedMax >= this.targetNeedIdx && t || this.freeSlots <= 0 && t) return;
+          await this.openDecoder();
+          const r = this.freeSlots > 0 ? this.freeSlots : 1, s = Math.max(1, Math.min(2, r));
+          if (this.decoder.decodeQueueSize >= s) return;
+          this.feedOneChunk(), this.chunksFed % 2 === 0 && await new Promise((i) => setTimeout(i, 0));
+        }
+      } finally {
+        this.pumping = !1;
+      }
+    }
+  }
+}
+function b(o, e, t) {
+  if (o.length === 0) return 0;
+  const r = o.length;
+  if (t <= o[0]) return 0;
+  const s = o[r - 1];
+  if (t >= e || t >= s) return r - 1;
+  let i = 0, n = r - 1;
+  for (; i + 1 < n; ) {
+    const d = i + n >>> 1;
+    o[d] <= t ? i = d : n = d;
+  }
+  return i;
+}
+function O(o, e) {
+  if (e.length === 0) return 1e-6;
+  const t = e.length, r = t - 1, s = e[r], i = t >= 2 ? e[r] - e[r - 1] : 1 / 30, n = s + i;
+  let d = o > 0 ? o : n;
+  if (!(d > 0) && t >= 2) {
+    const c = (e[t - 1] - e[0]) / (t - 1);
+    d = e[t - 1] + (c > 0 ? c : 1 / 30);
+  }
+  return d > 0 || (d = Math.max(n, 1 / 30)), d;
+}
+function q(o, e) {
+  var t, r;
+  if (o.length === 0) return new Float64Array(0);
+  const s = o.map((n, d) => d);
+  s.sort((n, d) => {
+    var c, l, h, f;
+    const y = o[n], m = o[d], a = (l = (c = y.cts) != null ? c : y.dts) != null ? l : 0, g = (f = (h = m.cts) != null ? h : m.dts) != null ? f : 0;
+    return a !== g ? a - g : n - d;
+  });
+  const i = new Float64Array(s.length);
+  for (let n = 0; n < s.length; n++) {
+    const d = o[s[n]];
+    i[n] = ((r = (t = d.cts) != null ? t : d.dts) != null ? r : 0) / e;
+  }
+  return i;
+}
+function L(o) {
+  return [...o].sort((e, t) => {
+    var r, s, i, n;
+    const d = ((s = (r = e.dts) != null ? r : e.cts) != null ? s : 0) - ((n = (i = t.dts) != null ? i : t.cts) != null ? n : 0);
+    return d !== 0 ? d : 0;
+  });
+}
+function W(o, e) {
+  if (o.length === 0) return 0;
+  const t = e / 1e6;
+  let r = 0, s = 1 / 0;
+  for (let i = 0; i < o.length; i++) {
+    const n = Math.abs(o[i] - t);
+    n < s && (s = n, r = i);
+  }
+  return r;
+}
+function V(o) {
+  for (let e = 0; e < o.length; e++)
+    if (o[e].is_sync) return e;
+  return 0;
+}
+async function A(o, e) {
+  var t;
+  const r = {
+    codec: o,
+    hardwareAcceleration: "prefer-software",
+    ...e && e.byteLength > 0 ? { description: e } : {}
+  };
+  let s = await VideoDecoder.isConfigSupported(r), i = r;
+  if (!s.supported) {
+    const n = {
+      codec: o,
+      ...e && e.byteLength > 0 ? { description: e } : {}
+    };
+    if (s = await VideoDecoder.isConfigSupported(n), !s.supported)
+      throw new Error(`WebCodecs: unsupported config ${o}`);
+    i = n;
+  }
+  return (t = s.config) != null ? t : i;
+}
+let p = null;
+self.onmessage = (o) => {
+  const e = o.data;
+  if (e) {
+    if (e.type === "init") {
+      H(e);
+      return;
+    }
+    if (!(!p || e.id !== p.id)) {
+      if (e.type === "ensure") {
+        p.decoder.ensure(e.needIdx, e.freeSlots);
+        return;
+      }
+      if (e.type === "rewind") {
+        p.decoder.rewind();
+        return;
+      }
+      e.type === "destroy" && (p.decoder.destroy(), p = null);
+    }
+  }
+};
+async function H(o) {
+  p && (p.decoder.destroy(), p = null);
+  const e = o.id;
+  try {
+    const t = await E(o.buffer);
+    if (t.samples.length === 0) {
+      self.postMessage({ type: "error", id: e, message: "mp4box: no samples" });
+      return;
+    }
+    const r = L(t.samples), s = q(t.samples, t.timescale), i = O(t.durationSec, s), n = t.videoWidth || 0, d = t.videoHeight || 0, c = new Float64Array(s.length);
+    c.set(s), self.postMessage(
+      {
+        type: "meta",
+        id: e,
+        duration: i,
+        videoWidth: n,
+        videoHeight: d,
+        frameCount: s.length,
+        timesSec: c
+      },
+      { transfer: [c.buffer] }
+    );
+    const l = t.samples[0] ? await C(
+      t.samples[0].description
+    ) : void 0, h = b(s, i, 0), f = Math.min(
+      s.length - 1,
+      Math.max(0, h + Math.max(0, o.decodeAheadFrames))
+    ), y = new T(
+      r,
+      s,
+      t.timescale,
+      t.codec,
+      l,
+      i,
+      {
+        onFrame: (m, a) => {
+          self.postMessage({ type: "frame", id: e, index: m, frame: a }, { transfer: [a] });
+        },
+        onEos: () => {
+          self.postMessage({ type: "eos", id: e });
+        },
+        onError: (m) => {
+          console.error("[GiftStage:WC] worker VideoDecoder error", m);
+        }
+      },
+      f
+    );
+    p = { id: e, decoder: y };
+  } catch (t) {
+    self.postMessage({
+      type: "error",
+      id: e,
+      message: t instanceof Error ? t.message : String(t)
+    });
+  }
+}
+//# sourceMappingURL=webcodecs-mp4.worker-DeS4ARzq.js.map

package/dist/core/gift-stage.d.ts

@@ -13,6 +13,11 @@ export declare class GiftStage {
     private static readonly DEFAULT_RESOURCE_CACHE_PERSISTENT_BYTES;
     private readonly sharedSVGAEntities;
     private readonly pendingSharedSVGAEntities;
+    /** One full clip-prewarm task per entity, shared by every slot using that entity. */
+    private readonly svgaFullClipPrewarmPromises;
+    /** Deferred persistent-cache writer captured while a URL-backed entity is being assembled. */
+    private readonly svgaPersistentCacheWriters;
+    private readonly svgaPersistentCacheWritePromises;
     private readonly sharedVideoSources;
     private readonly sharedHtmlVideos;
     private readonly sharedVideoTextures;
@@ -79,13 +84,11 @@ export declare class GiftStage {
      */
     private decodeSVGAAudioInBackground;
     /**
-     * Builds an SVGA's clip meshes after its first frame has already been painted (see
-     * `primeSVGAFirstFrame`). Detached from the `finishLoadSVGA` promise chain; the render loop's
-     * own on-demand fallback (`SVGABatchRenderer.getClipMeshForSprite`, see P1-9) already covers
-     * correctness for any sprite drawn before this finishes, so this is purely a prefetch that lets
-     * later frames skip the render loop's slower one-path-at-a-time queueing.
+     * Starts or reuses the entity-wide clip prewarm. It is deliberately independent of any one
+     * slot's abort signal: shared entities can outlive the slot that first requested the work.
      */
-    private prewarmSVGAClipMeshesInBackground;
+    private ensureSVGAFullClipPrewarm;
+    private queueSVGAPersistentCacheWrite;
     private svgaAtlasMaxSize;
     private buildSVGAAtlasIfNeeded;
     private svgaAtlasMaxPages;

package/dist/core/render-manager.d.ts

@@ -95,6 +95,13 @@ export declare class RenderManager {
         checkActive?: () => void;
         signal?: AbortSignal;
     }): Promise<number>;
+    prewarmSVGAClipMeshesForFrame(entity: NonNullable<GiftSlot['videoEntity']>, frame: number, options?: {
+        frameBudgetMs?: number;
+        workerTimeSliceMs?: number;
+        useWorker?: boolean;
+        checkActive?: () => void;
+        signal?: AbortSignal;
+    }): Promise<number>;
     hydrateSVGAClipMeshes(meshes: SVGAClipMeshMap | null | undefined): void;
     snapshotSVGAClipMeshes(entity: NonNullable<GiftSlot['videoEntity']>): SVGAClipMeshMap;
     private renderLoop;