pixi-effects 0.26.0 → 0.26.2

package/dist/{chunk-PRZ4U6JN.js → chunk-X3HB4DSR.js}

@@ -2965,7 +2965,7 @@ var AudioSequence = class extends Sequence {
     const raw = spec;
     if (raw.asset !== void 0) console.warn(`pixi-effects: ${who}: has both asset and music \u2014 the music plays; remove one`);
     if (raw.sfx !== void 0) console.warn(`pixi-effects: ${who}: has both sfx and music \u2014 the music plays; remove one`);
-    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-AF4VTFAF.js');
+    const { resolveMusic, renderMusic, musicLength, musicKey } = await import('./music-3O5MDQXY.js');
     const music = resolveMusic(spec.music, who);
     if (!music) return;
     const natural = musicLength(music);
@@ -3042,19 +3042,41 @@ var AudioSequence = class extends Sequence {
 };
 
 // src/core/FrameCache.ts
+var BUDGET_BYTES = 96 * 1024 * 1024;
+var MIN_HELD = 3;
+var JUMP_SECONDS = 1;
+var EPS = 1e-6;
+function reportDecodeError(err, time) {
+  const isTransient = err instanceof DOMException && (err.name === "EncodingError" || err.name === "NotSupportedError");
+  if (isTransient) console.debug("pixi-effects: transient video decode failure at", time, "s \u2014", err.name);
+  else console.warn("pixi-effects: video frame decode failed at", time, "s \u2014", err);
+}
 var FrameCache = class {
   sink;
   capacity;
   cache = /* @__PURE__ */ new Map();
   _pending = /* @__PURE__ */ new Map();
+  // Sequential mode (the sink has `samples()`): one decoder pass that runs forward as the movie asks for frame after frame.
+  _frames = [];
+  _cur = null;
+  _iter = null;
+  _next = null;
+  _held = 0;
+  _lock = Promise.resolve();
+  _lastTime = null;
   constructor(sink, options = {}) {
     this.sink = sink;
     this.capacity = options.capacity ?? 30;
   }
+  /** How many decoded frames are held right now (the sequential reader's own list, plus the exact-time cache of the old path). */
+  get heldFrames() {
+    return this._frames.length + this.cache.size;
+  }
   _key(time) {
     return Math.round(time * 1e6);
   }
   async getFrameAt(time) {
+    if (this.sink.samples) return this._enqueue(() => this._sequentialAt(time));
     const key = this._key(time);
     if (this.cache.has(key)) {
       const v = this.cache.get(key);
@@ -3092,15 +3114,138 @@ var FrameCache = class {
       sample.close?.();
       return frame;
     } catch (err) {
-      const isTransient = err instanceof DOMException && (err.name === "EncodingError" || err.name === "NotSupportedError");
-      if (isTransient) {
-        console.debug("pixi-effects: transient video decode failure at", time, "s \u2014", err.name);
-      } else {
-        console.warn("pixi-effects: video frame decode failed at", time, "s \u2014", err);
+      reportDecodeError(err, time);
+      return null;
+    }
+  }
+  // ── sequential mode ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  /** Requests are answered one at a time, in the order they arrive: one pass cannot serve two places at once. */
+  _enqueue(fn) {
+    const run = this._lock.then(fn, fn);
+    this._lock = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  _covering(time) {
+    for (const e of this._frames) {
+      if (e.end === null ? e.req !== void 0 && Math.abs(e.req - time) < EPS : e.ts <= time + EPS && time < e.end - EPS) {
+        this._frames.splice(this._frames.indexOf(e), 1);
+        this._frames.push(e);
+        return e;
       }
+    }
+    return null;
+  }
+  async _sequentialAt(time) {
+    try {
+      const last = this._lastTime;
+      this._lastTime = time;
+      const hit = this._covering(time);
+      if (hit) return hit.frame;
+      if (last === null || Math.abs(time - last) > JUMP_SECONDS) return await this._single(time);
+      const cur = this._cur;
+      if (this._iter && cur && time >= cur.ts && time - cur.ts <= JUMP_SECONDS) return await this._advance(time);
+      const backwards = !!cur && time < cur.ts;
+      return await this._restart(time, backwards ? Math.max(0, time - this._held / 30) : time);
+    } catch (err) {
+      reportDecodeError(err, time);
+      await this._closeIter();
       return null;
     }
   }
+  /** One frame by itself (a seek): getSample, kept so that asking again for the same time costs nothing. The running pass, if any, is closed: it no longer follows the playhead. */
+  async _single(time) {
+    await this._closeIter();
+    this._cur = null;
+    const sample = await this.sink.getSample(time);
+    if (!sample) return null;
+    const frame = sample.toVideoFrame();
+    sample.close?.();
+    this._keep({ ts: sample.timestamp, end: null, frame, req: time }, frame);
+    return frame;
+  }
+  /** Start a pass at `time` (a seek and the frames of one group of pictures), keeping what is still held for a step back. */
+  async _restart(time, from = time) {
+    await this._closeIter();
+    this._cur = null;
+    const iter = this.sink.samples(from);
+    this._iter = iter;
+    const first = await iter.next();
+    if (first.done) {
+      await this._closeIter();
+      return null;
+    }
+    if (first.value.timestamp > time + EPS) {
+      first.value.close?.();
+      await this._closeIter();
+      return null;
+    }
+    this._take(first.value);
+    return this._advance(time);
+  }
+  /** Run the pass forward until the frame that covers `time` is the current one; the next frame is read ahead (its start is where this one ends). */
+  async _advance(time) {
+    const cur = () => this._cur;
+    for (; ; ) {
+      if (!this._next) {
+        let r;
+        try {
+          r = await this._iter.next();
+        } catch (err) {
+          reportDecodeError(err, time);
+          await this._closeIter();
+          const prev = this._frames.length > 1 ? this._frames[this._frames.length - 2] : null;
+          const spacing = prev ? cur().ts - prev.ts : 1 / 24;
+          return time < cur().ts + spacing - EPS ? cur().frame : null;
+        }
+        if (r.done) {
+          cur().end = Infinity;
+          this._iter = null;
+          break;
+        }
+        this._next = r.value;
+      }
+      cur().end = this._next.timestamp;
+      if (this._next.timestamp <= time + EPS) {
+        const s = this._next;
+        this._next = null;
+        this._take(s);
+      } else break;
+    }
+    return cur().frame;
+  }
+  _take(sample) {
+    const frame = sample.toVideoFrame();
+    sample.close?.();
+    const entry = { ts: sample.timestamp, end: null, frame };
+    this._keep(entry, frame);
+    this._cur = entry;
+  }
+  /** Hold a frame (the first one sets how many fit: a byte budget, not a count) and close the oldest beyond that; the frame the pass stands on is never closed. */
+  _keep(entry, frame) {
+    if (this._held === 0) {
+      const bytes = frame.allocationSize?.() ?? frame.displayWidth * frame.displayHeight * 1.5;
+      this._held = Math.max(MIN_HELD, Math.min(this.capacity, Math.floor(BUDGET_BYTES / Math.max(1, bytes))));
+    }
+    this._frames.push(entry);
+    while (this._frames.length > this._held) {
+      const oldest = this._frames.find((e) => e !== this._cur && e !== entry);
+      if (!oldest) break;
+      this._frames.splice(this._frames.indexOf(oldest), 1);
+      oldest.frame.close?.();
+    }
+  }
+  async _closeIter() {
+    const iter = this._iter;
+    this._iter = null;
+    this._next?.close?.();
+    this._next = null;
+    if (iter) {
+      try {
+        await iter.return?.(void 0);
+      } catch {
+      }
+    }
+  }
   _evictIfNeeded() {
     while (this.cache.size > this.capacity) {
       const oldestKey = this.cache.keys().next().value;
@@ -3114,6 +3259,14 @@ var FrameCache = class {
     for (const f of this.cache.values()) f?.close?.();
     this.cache.clear();
     this._pending.clear();
+    for (const e of this._frames) e.frame.close?.();
+    this._frames = [];
+    this._cur = null;
+    this._next?.close?.();
+    this._next = null;
+    const iter = this._iter;
+    this._iter = null;
+    void iter?.return?.(void 0);
   }
 };
 
@@ -4344,7 +4497,7 @@ function resolveDim(v, scope) {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-C4FSWJZF.js')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-H4QA24MV.js')).CompositionSequence;
   }
   return _CompositionSequence;
 }
@@ -4372,10 +4525,12 @@ async function buildSequenceTree(specs, parent, root) {
     }
     if (!Cls) {
       console.warn(`pixi-effects: unknown sequence type "${spec.type}"`);
+      await root.onLayerBuilt?.();
       continue;
     }
     const seq = new Cls(spec, parent, root);
     await seq.build();
+    await root.onLayerBuilt?.();
     if (seq.duration === void 0) {
       seq.duration = parent?.duration ?? root.duration;
     }
@@ -4385,5 +4540,5 @@ async function buildSequenceTree(specs, parent, root) {
 }
 
 export { CameraSequence, DEFAULT_FOV, DEG2 as DEG, FALLOFFS, LIGHT_KINDS, LIGHT_PROPS, LightSequence, MANY_BLURRED, MAX_BLUR, MAX_CASTERS, MAX_LIGHTS, MIN_BLUR, NEAR, NullSequence, SHADOW_TAPS, Sequence, bindClock, blurRadius, buildScope, buildSequenceTree, cameraBasis, checkEase, clockTable, contentLength, ensureFilterLibrary, evaluateExpr, flattenSvgPath, focusProblems, homeCamera, homeDistance, layerInitialZ, layerToWorld, lightLevel, noise, packLights, projectLayer, projectPoint, rand, random, registerSequenceType, remapOf, resolveAt, timeRemapOf };
-//# sourceMappingURL=chunk-PRZ4U6JN.js.map
-//# sourceMappingURL=chunk-PRZ4U6JN.js.map
+//# sourceMappingURL=chunk-X3HB4DSR.js.map
+//# sourceMappingURL=chunk-X3HB4DSR.js.map