@taole/giftstage 0.1.33 → 0.1.34

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

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

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

@@ -1,4 +1,4 @@
-import type { GiftSlot, GiftHandle } from '../types';
+import type { GiftSlot } from '../types';
 export declare class AudioManager {
     private ctx;
     private decodedCache;
@@ -11,7 +11,14 @@ export declare class AudioManager {
      * Frame-synced playback: start audio on startFrame, stop on endFrame.
      * Matches SVGAPlayer-Web-master Canvas/renderer.js playAudio() pattern.
      */
-    tickFrame(slot: GiftSlot, currentFrame: number, _handle: GiftHandle): void;
+    tickFrame(slot: GiftSlot, currentFrame: number): void;
+    /**
+     * Catch-up trigger for a single audio key once its buffer finishes decoding in the background
+     * (see `GiftStage`'s deferred SVGA audio decode). Only re-checks entries using `audioKey` —
+     * unlike `tickFrame`, which re-scans every audio and would otherwise risk double-starting a
+     * sibling audio that already played this frame if called again with an unchanged frame number.
+     */
+    tickFrameForKey(slot: GiftSlot, currentFrame: number, audioKey: string): void;
     private startAudio;
     stopAllForGift(giftId: string): void;
     setMute(mute: boolean): void;

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

@@ -36,6 +36,7 @@ export declare class GiftStage {
     private nextSharedWebCodecsPlaybackId;
     private nextSharedWebCodecsSurfaceId;
     private readonly onWindowLayout;
+    private readonly onVisibilityChange;
     constructor(options: GiftStageOptions);
     private backingStoreDpr;
     private syncCanvasSize;
@@ -63,6 +64,28 @@ export declare class GiftStage {
     private deleteSVGAAtlasTextures;
     private deleteSVGAAtlasResultTextures;
     private finishLoadSVGA;
+    /**
+     * Flips a freshly-attached SVGA slot to 'playing' and forces an immediate redraw, instead of
+     * waiting for `addGift`'s shared post-load bookkeeping (which only runs once every gift type's
+     * loader — including this SVGA path's now-backgrounded audio decode / clip prewarm — settles).
+     * Idempotent no-op once the slot has left the 'loading' state (`addGift` skips re-running its
+     * own copy of this priming when it sees that already happened).
+     */
+    private primeSVGAFirstFrame;
+    /**
+     * Decodes an SVGA's audio blobs after its first frame has already been painted (see
+     * `primeSVGAFirstFrame`). Detached from the `finishLoadSVGA` promise chain, so failures/
+     * cancellation must be handled here instead of propagating to `loadSVGA`'s caller.
+     */
+    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.
+     */
+    private prewarmSVGAClipMeshesInBackground;
     private svgaAtlasMaxSize;
     private buildSVGAAtlasIfNeeded;
     private svgaAtlasMaxPages;

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

@@ -17,6 +17,8 @@ export declare class RenderManager {
     private lastTime;
     private running;
     private globallyPaused;
+    /** Set while the document is hidden (`GiftStage.setHidden`); suppresses rAF independent of `globallyPaused`. */
+    private suspendedForHidden;
     private forceNextDraw;
     private readonly onAnimationFrame;
     private readonly onHtmlVideoFrame;
@@ -35,6 +37,7 @@ export declare class RenderManager {
     private readonly activeSharedWebCodecsScratch;
     constructor(backend: GPUBackend);
     addSlot(slot: GiftSlot, handle: GiftHandle): void;
+    getHandle(id: string): GiftHandle | undefined;
     releaseSlotResources(slot: GiftSlot): void;
     removeSlot(id: string): void;
     getSlot(id: string): GiftSlot | undefined;
@@ -63,6 +66,28 @@ export declare class RenderManager {
     private clearFrameOnce;
     pause(): void;
     resume(): void;
+    /**
+     * Tab-visibility throttle: stops the rAF loop while hidden (SVGA/WebCodecs `ensure` calls and
+     * uploads otherwise keep running, even though most browsers already cap rAF in the
+     * background) and resets the render clock on return so the next frame doesn't see a huge
+     * stale `dt`. Independent of {@link pause}/{@link resume} — an explicit user pause stays
+     * paused after the tab becomes visible again, and an explicit resume while still hidden does
+     * not restart rAF until the tab is visible.
+     */
+    setHidden(hidden: boolean): void;
+    private syncAllVideoPlayback;
+    /**
+     * Whether some slot other than `excludeId` still needs `video` actively playing right now.
+     * Shared `<video>` elements (`releaseSharedVideoPlayback` set) must keep decoding while any
+     * consumer in the group is still active, even if the slot we're syncing just paused.
+     */
+    private hasActiveVideoConsumer;
+    /**
+     * Sync a single slot's underlying `<video>` element to its current active state. Non-shared
+     * videos pause/resume 1:1 with the slot; shared videos only pause once every consumer in the
+     * group has gone inactive, so one paused copy never stalls playback for the rest.
+     */
+    syncVideoPlaybackForSlot(slot: GiftSlot): void;
     prewarmSVGAClipMeshes(entity: NonNullable<GiftSlot['videoEntity']>, options?: {
         frameBudgetMs?: number;
         workerTimeSliceMs?: number;