avbridge 2.1.2 → 2.2.1

package/dist/element-browser.js

@@ -145,6 +145,9 @@ function sniffContainerFromBytes(head) {
   }
   if (head[0] === 48 && head[1] === 38 && head[2] === 178 && head[3] === 117 && head[4] === 142 && head[5] === 102 && head[6] === 207 && head[7] === 17) return "asf";
   if (head[0] === 70 && head[1] === 76 && head[2] === 86) return "flv";
+  if (head[0] === 46 && head[1] === 82 && head[2] === 77 && head[3] === 70) {
+    return "rm";
+  }
   if (head[0] === 79 && head[1] === 103 && head[2] === 103 && head[3] === 83) return "ogg";
   if (head[0] === 102 && head[1] === 76 && head[2] === 97 && head[3] === 67) return "flac";
   if (head[0] === 73 && head[1] === 68 && head[2] === 51) return "mp3";
@@ -29628,6 +29631,98 @@ var init_libav_http_reader = __esm({
   }
 });
 
+// src/util/debug.ts
+function isDebugEnabled() {
+  if (typeof globalThis === "undefined") return false;
+  const g = globalThis;
+  if (g.AVBRIDGE_DEBUG === true) return true;
+  if (typeof location !== "undefined" && typeof URLSearchParams !== "undefined") {
+    try {
+      const p = new URLSearchParams(location.search);
+      if (p.has("avbridge_debug")) {
+        g.AVBRIDGE_DEBUG = true;
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function fmt(tag) {
+  return `[avbridge:${tag}]`;
+}
+function hintForTag(tag) {
+  switch (tag) {
+    case "probe":
+      return "slow network (range request), large sniff window, or libav cold-start";
+    case "libav-load":
+      return "large .wasm download, misconfigured AVBRIDGE_LIBAV_BASE, or server-side MIME type";
+    case "bootstrap":
+      return "probe+classify+strategy-init chain; enable AVBRIDGE_DEBUG for a phase breakdown";
+    case "cold-start":
+      return "decoder is producing output slower than realtime \u2014 check framesDecoded in getDiagnostics()";
+    default:
+      return "unknown stage \u2014 enable globalThis.AVBRIDGE_DEBUG for more detail";
+  }
+}
+var dbg;
+var init_debug = __esm({
+  "src/util/debug.ts"() {
+    dbg = {
+      /** Verbose — only when debug is enabled. The hot-path normal case. */
+      info(tag, ...args) {
+        if (isDebugEnabled()) console.info(fmt(tag), ...args);
+      },
+      /** Warning — only when debug is enabled. Non-fatal oddities. */
+      warn(tag, ...args) {
+        if (isDebugEnabled()) console.warn(fmt(tag), ...args);
+      },
+      /**
+       * Self-diagnosis warning. **Always** emits regardless of debug flag.
+       * Use this only for conditions that mean something is actually wrong
+       * or degraded — not for routine chatter.
+       */
+      diag(tag, ...args) {
+        console.warn(fmt(tag), ...args);
+      },
+      /**
+       * Timing helper: wraps an async call and logs its elapsed time when
+       * debug is on. The callback runs whether debug is on or off — this is
+       * just for the `dbg.info` at the end.
+       *
+       * Also unconditionally fires `dbg.diag` if the elapsed time exceeds
+       * `slowMs`, so "the bootstrap took 8 seconds" shows up even without
+       * debug mode enabled.
+       */
+      async timed(tag, label, slowMs, fn) {
+        const start = performance.now();
+        try {
+          const result = await fn();
+          const elapsed = performance.now() - start;
+          if (isDebugEnabled()) {
+            console.info(fmt(tag), `${label} ${elapsed.toFixed(0)}ms`);
+          }
+          if (elapsed > slowMs) {
+            console.warn(
+              fmt(tag),
+              `${label} took ${elapsed.toFixed(0)}ms (>${slowMs}ms expected) \u2014 this is unusually slow; possible causes: ${hintForTag(tag)}`
+            );
+          }
+          return result;
+        } catch (err) {
+          const elapsed = performance.now() - start;
+          console.warn(
+            fmt(tag),
+            `${label} FAILED after ${elapsed.toFixed(0)}ms:`,
+            err
+          );
+          throw err;
+        }
+      }
+    };
+  }
+});
+
 // src/strategies/fallback/libav-loader.ts
 function cacheKey(variant, threads) {
   return `${variant}:${threads ? "thr" : "wasm"}`;
@@ -29644,9 +29739,18 @@ function loadLibav(variant = "webcodecs", opts = {}) {
   return entry;
 }
 async function loadVariant(variant, wantThreads) {
+  return dbg.timed(
+    "libav-load",
+    `load "${variant}" (threads=${wantThreads})`,
+    5e3,
+    () => loadVariantInner(variant, wantThreads)
+  );
+}
+async function loadVariantInner(variant, wantThreads) {
   const key = cacheKey(variant, wantThreads);
   const base = `${libavBaseUrl()}/${variant}`;
   const variantUrl = `${base}/libav-${variant}.mjs`;
+  dbg.info("libav-load", `fetching ${variantUrl}`);
   if (typeof fetch === "function") {
     try {
       const head = await fetch(variantUrl, { method: "GET", headers: { Range: "bytes=0-0" } });
@@ -29730,6 +29834,7 @@ function chain(message, err) {
 var cache;
 var init_libav_loader = __esm({
   "src/strategies/fallback/libav-loader.ts"() {
+    init_debug();
     cache = /* @__PURE__ */ new Map();
   }
 });
@@ -29858,7 +29963,12 @@ function ffmpegToAvbridgeVideo(name) {
       return "mpeg1";
     case "theora":
       return "theora";
+    case "rv10":
+      return "rv10";
+    case "rv20":
+      return "rv20";
     case "rv30":
+      return "rv30";
     case "rv40":
       return "rv40";
     default:
@@ -29889,6 +29999,16 @@ function ffmpegToAvbridgeAudio(name) {
       return "wmapro";
     case "alac":
       return "alac";
+    case "cook":
+      return "cook";
+    case "ra_144":
+      return "ra_144";
+    case "ra_288":
+      return "ra_288";
+    case "sipr":
+      return "sipr";
+    case "atrac3":
+      return "atrac3";
     default:
       return name;
   }
@@ -31154,8 +31274,29 @@ var NATIVE_AUDIO_CODECS = /* @__PURE__ */ new Set([
   "vorbis",
   "flac"
 ]);
-var FALLBACK_VIDEO_CODECS = /* @__PURE__ */ new Set(["wmv3", "vc1", "mpeg4", "rv40", "mpeg2", "mpeg1", "theora"]);
-var FALLBACK_AUDIO_CODECS = /* @__PURE__ */ new Set(["wmav2", "wmapro", "ac3", "eac3"]);
+var FALLBACK_VIDEO_CODECS = /* @__PURE__ */ new Set([
+  "wmv3",
+  "vc1",
+  "mpeg4",
+  "rv10",
+  "rv20",
+  "rv30",
+  "rv40",
+  "mpeg2",
+  "mpeg1",
+  "theora"
+]);
+var FALLBACK_AUDIO_CODECS = /* @__PURE__ */ new Set([
+  "wmav2",
+  "wmapro",
+  "ac3",
+  "eac3",
+  "cook",
+  "ra_144",
+  "ra_288",
+  "sipr",
+  "atrac3"
+]);
 var NATIVE_CONTAINERS = /* @__PURE__ */ new Set([
   "mp4",
   "mov",
@@ -31837,6 +31978,10 @@ async function createRemuxPipeline(ctx, video) {
         console.error("[avbridge] remux pipeline reseek failed:", err);
       });
     },
+    setAutoPlay(autoPlay) {
+      pendingAutoPlay = autoPlay;
+      if (sink) sink.setPlayOnSeek(autoPlay);
+    },
     async destroy() {
       destroyed = true;
       pumpToken++;
@@ -31877,7 +32022,11 @@ async function createRemuxSession(context, video) {
         await pipeline.start(video.currentTime || 0, true);
         return;
       }
-      await video.play();
+      pipeline.setAutoPlay(true);
+      try {
+        await video.play();
+      } catch {
+      }
     },
     pause() {
       wantPlay = false;
@@ -31925,7 +32074,7 @@ var VideoRenderer = class {
       this.resolveFirstFrame = resolve;
     });
     this.canvas = document.createElement("canvas");
-    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;";
+    this.canvas.style.cssText = "position:absolute;left:0;top:0;width:100%;height:100%;background:black;object-fit:contain;";
     const parent = target.parentElement ?? target.parentNode;
     if (parent && parent instanceof HTMLElement) {
       if (getComputedStyle(parent).position === "static") {
@@ -32167,9 +32316,13 @@ var AudioOutput = class {
     const node3 = this.ctx.createBufferSource();
     node3.buffer = buffer;
     node3.connect(this.gain);
-    const ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
-    const safeStart = Math.max(ctxStart, this.ctx.currentTime);
-    node3.start(safeStart);
+    let ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor);
+    if (ctxStart < this.ctx.currentTime) {
+      this.ctxTimeAtAnchor = this.ctx.currentTime;
+      this.mediaTimeOfAnchor = this.mediaTimeOfNext;
+      ctxStart = this.ctx.currentTime;
+    }
+    node3.start(ctxStart);
     this.mediaTimeOfNext += frameCount / sampleRate;
     this.framesScheduled++;
   }
@@ -32764,6 +32917,10 @@ async function createHybridSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -32828,6 +32985,7 @@ async function createHybridSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
       } catch {
       }
     },
@@ -32906,6 +33064,10 @@ async function startDecoder(opts) {
   let packetsRead = 0;
   let videoFramesDecoded = 0;
   let audioFramesDecoded = 0;
+  let watchdogFirstFrameMs = 0;
+  let watchdogSlowSinceMs = 0;
+  let watchdogSlowWarned = false;
+  let watchdogOverflowWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
@@ -32926,14 +33088,47 @@ async function startDecoder(opts) {
       if (myToken !== pumpToken || destroyed) return;
       const videoPackets = videoStream ? packets[videoStream.index] : void 0;
       const audioPackets = audioStream ? packets[audioStream.index] : void 0;
-      if (videoDec && videoPackets && videoPackets.length > 0) {
-        await decodeVideoBatch(videoPackets, myToken);
-      }
-      if (myToken !== pumpToken || destroyed) return;
       if (audioDec && audioPackets && audioPackets.length > 0) {
         await decodeAudioBatch(audioPackets, myToken);
       }
+      if (myToken !== pumpToken || destroyed) return;
+      if (videoDec && videoPackets && videoPackets.length > 0) {
+        await decodeVideoBatch(videoPackets, myToken);
+      }
       packetsRead += (videoPackets?.length ?? 0) + (audioPackets?.length ?? 0);
+      if (videoFramesDecoded > 0) {
+        if (watchdogFirstFrameMs === 0) {
+          watchdogFirstFrameMs = performance.now();
+        }
+        const elapsedSinceFirst = (performance.now() - watchdogFirstFrameMs) / 1e3;
+        if (elapsedSinceFirst > 1 && !watchdogSlowWarned) {
+          const expectedFrames = elapsedSinceFirst * videoFps;
+          const ratio = videoFramesDecoded / expectedFrames;
+          if (ratio < 0.6) {
+            if (watchdogSlowSinceMs === 0) watchdogSlowSinceMs = performance.now();
+            if ((performance.now() - watchdogSlowSinceMs) / 1e3 > 5) {
+              watchdogSlowWarned = true;
+              console.warn(
+                "[avbridge:decode-rate]",
+                `decoder is running slower than realtime: ${videoFramesDecoded} frames in ${elapsedSinceFirst.toFixed(1)}s (${(videoFramesDecoded / elapsedSinceFirst).toFixed(1)} fps vs ${videoFps} fps source \u2014 ${(ratio * 100).toFixed(0)}% of realtime). Playback will stutter. Typical causes: software decode of a codec with no WebCodecs support (rv40, mpeg4 @ 720p+, wmv3), or a resolution too large for single-threaded WASM to keep up with.`
+              );
+            }
+          } else {
+            watchdogSlowSinceMs = 0;
+          }
+        }
+        if (!watchdogOverflowWarned && videoFramesDecoded > 100) {
+          const rendererStats = opts.renderer.stats();
+          const overflow = rendererStats.framesDroppedOverflow ?? 0;
+          if (overflow / videoFramesDecoded > 0.1) {
+            watchdogOverflowWarned = true;
+            console.warn(
+              "[avbridge:overflow-drop]",
+              `renderer is dropping ${overflow}/${videoFramesDecoded} frames (${(overflow / videoFramesDecoded * 100).toFixed(0)}%) because the decoder is producing bursts faster than the canvas can drain. Symptom: choppy playback despite decoder keeping up on average. Fix would be smaller read batches in the pump loop or a lower queueHighWater cap \u2014 see src/strategies/fallback/decoder.ts.`
+            );
+          }
+        }
+      }
       while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
         await new Promise((r) => setTimeout(r, 50));
       }
@@ -33260,8 +33455,9 @@ async function loadBridge2() {
 }
 
 // src/strategies/fallback/index.ts
-var READY_AUDIO_BUFFER_SECONDS2 = 0.3;
-var READY_TIMEOUT_SECONDS2 = 10;
+init_debug();
+var READY_AUDIO_BUFFER_SECONDS2 = 0.04;
+var READY_TIMEOUT_SECONDS2 = 3;
 async function createFallbackSession(ctx, target) {
   const { normalizeSource: normalizeSource2 } = await Promise.resolve().then(() => (init_source(), source_exports));
   const source = await normalizeSource2(ctx.source);
@@ -33289,6 +33485,10 @@ async function createFallbackSession(ctx, target) {
       void doSeek(v);
     }
   });
+  Object.defineProperty(target, "paused", {
+    configurable: true,
+    get: () => !audio.isPlaying()
+  });
   if (ctx.duration && Number.isFinite(ctx.duration)) {
     Object.defineProperty(target, "duration", {
       configurable: true,
@@ -33297,12 +33497,36 @@ async function createFallbackSession(ctx, target) {
   }
   async function waitForBuffer() {
     const start = performance.now();
+    let firstFrameAtMs = 0;
+    dbg.info(
+      "cold-start",
+      `gate entry: want audio \u2265 ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms + 1 frame`
+    );
     while (true) {
-      const audioReady = audio.isNoAudio() || audio.bufferAhead() >= READY_AUDIO_BUFFER_SECONDS2;
-      if (audioReady && renderer.hasFrames()) {
+      const audioAhead = audio.isNoAudio() ? Infinity : audio.bufferAhead();
+      const audioReady = audio.isNoAudio() || audioAhead >= READY_AUDIO_BUFFER_SECONDS2;
+      const hasFrames = renderer.hasFrames();
+      const nowMs = performance.now();
+      if (hasFrames && firstFrameAtMs === 0) firstFrameAtMs = nowMs;
+      if (audioReady && hasFrames) {
+        dbg.info(
+          "cold-start",
+          `gate satisfied in ${(nowMs - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
+        );
         return;
       }
-      if ((performance.now() - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
+      if (hasFrames && firstFrameAtMs > 0 && nowMs - firstFrameAtMs >= 500) {
+        dbg.info(
+          "cold-start",
+          `gate released on video-only grace at ${(nowMs - start).toFixed(0)}ms (frames=${renderer.queueDepth()}, audio=${(audioAhead * 1e3).toFixed(0)}ms \u2014 demuxer hasn't delivered audio packets yet, starting anyway and letting the audio scheduler catch up at its media-time anchor)`
+        );
+        return;
+      }
+      if ((nowMs - start) / 1e3 > READY_TIMEOUT_SECONDS2) {
+        dbg.diag(
+          "cold-start",
+          `gate TIMEOUT after ${READY_TIMEOUT_SECONDS2}s \u2014 audio=${(audioAhead * 1e3).toFixed(0)}ms (needed ${READY_AUDIO_BUFFER_SECONDS2 * 1e3}ms), frames=${renderer.queueDepth()} (needed \u22651). Decoder produced nothing in ${READY_TIMEOUT_SECONDS2}s \u2014 either a corrupt source, a missing codec, or WASM is catastrophically slow on this file. Check getDiagnostics().runtime for decode counters.`
+        );
         return;
       }
       await new Promise((r) => setTimeout(r, 50));
@@ -33350,6 +33574,7 @@ async function createFallbackSession(ctx, target) {
       try {
         delete target.currentTime;
         delete target.duration;
+        delete target.paused;
       } catch {
       }
     },
@@ -33413,8 +33638,8 @@ function convertTiming(line) {
     line.trim()
   );
   if (!m) return null;
-  const fmt = (h, mm, s, ms) => `${h.padStart(2, "0")}:${mm}:${s}.${ms.padEnd(3, "0").slice(0, 3)}`;
-  return `${fmt(m[1], m[2], m[3], m[4])} --> ${fmt(m[5], m[6], m[7], m[8])}${m[9] ?? ""}`;
+  const fmt2 = (h, mm, s, ms) => `${h.padStart(2, "0")}:${mm}:${s}.${ms.padEnd(3, "0").slice(0, 3)}`;
+  return `${fmt2(m[1], m[2], m[3], m[4])} --> ${fmt2(m[5], m[6], m[7], m[8])}${m[9] ?? ""}`;
 }
 
 // src/subtitles/vtt.ts
@@ -33500,6 +33725,7 @@ async function attachSubtitleTracks(video, tracks, bag, onError) {
 }
 
 // src/player.ts
+init_debug();
 var UnifiedPlayer = class _UnifiedPlayer {
   /**
    * @internal Use {@link createPlayer} or {@link UnifiedPlayer.create} instead.
@@ -33522,6 +33748,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
   lastProgressTime = 0;
   lastProgressPosition = -1;
   errorListener = null;
+  // Bound so we can removeEventListener in destroy(); without this the
+  // listener outlives the player and accumulates on elements that swap
+  // source (e.g. <avbridge-video>).
+  endedListener = null;
   // Serializes escalation / setStrategy calls
   switchingPromise = Promise.resolve();
   // Owns blob URLs created during sidecar discovery + SRT->VTT conversion.
@@ -33547,8 +33777,14 @@ var UnifiedPlayer = class _UnifiedPlayer {
     return player;
   }
   async bootstrap() {
+    const bootstrapStart = performance.now();
     try {
-      const ctx = await probe(this.options.source);
+      dbg.info("bootstrap", "start");
+      const ctx = await dbg.timed("probe", "probe", 3e3, () => probe(this.options.source));
+      dbg.info(
+        "probe",
+        `container=${ctx.container} video=${ctx.videoTracks[0]?.codec ?? "-"} audio=${ctx.audioTracks[0]?.codec ?? "-"} probedBy=${ctx.probedBy}`
+      );
       this.diag.recordProbe(ctx);
       this.mediaContext = ctx;
       if (this.options.subtitles) {
@@ -33574,6 +33810,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
         }
       }
       const decision = this.options.initialStrategy ? buildInitialDecision(this.options.initialStrategy, ctx) : classifyContext(ctx);
+      dbg.info(
+        "classify",
+        `strategy=${decision.strategy} class=${decision.class} reason="${decision.reason}"` + (decision.fallbackChain ? ` fallback=${decision.fallbackChain.join("\u2192")}` : "")
+      );
       this.classification = decision;
       this.diag.recordClassification(decision);
       this.emitter.emitSticky("strategy", {
@@ -33597,8 +33837,17 @@ var UnifiedPlayer = class _UnifiedPlayer {
         subtitle: ctx.subtitleTracks
       });
       this.startTimeupdateLoop();
-      this.options.target.addEventListener("ended", () => this.emitter.emit("ended", void 0));
+      this.endedListener = () => this.emitter.emit("ended", void 0);
+      this.options.target.addEventListener("ended", this.endedListener);
       this.emitter.emitSticky("ready", void 0);
+      const bootstrapElapsed = performance.now() - bootstrapStart;
+      dbg.info("bootstrap", `ready in ${bootstrapElapsed.toFixed(0)}ms`);
+      if (bootstrapElapsed > 5e3) {
+        console.warn(
+          "[avbridge:bootstrap]",
+          `total bootstrap time ${bootstrapElapsed.toFixed(0)}ms \u2014 unusually slow. Enable globalThis.AVBRIDGE_DEBUG for a per-phase breakdown.`
+        );
+      }
     } catch (err) {
       const e = err instanceof Error ? err : new Error(String(err));
       this.diag.recordError(e);
@@ -33875,6 +34124,10 @@ var UnifiedPlayer = class _UnifiedPlayer {
       this.timeupdateInterval = null;
     }
     this.clearSupervisor();
+    if (this.endedListener) {
+      this.options.target.removeEventListener("ended", this.endedListener);
+      this.endedListener = null;
+    }
     if (this.session) {
       await this.session.destroy();
       this.session = null;
@@ -33889,11 +34142,13 @@ async function createPlayer(options) {
 function buildInitialDecision(initial, ctx) {
   const natural = classifyContext(ctx);
   const cls = strategyToClass(initial, natural);
+  const inherited = natural.fallbackChain ?? defaultFallbackChain(initial);
+  const fallbackChain = inherited.filter((s) => s !== initial);
   return {
     class: cls,
     strategy: initial,
     reason: `initial strategy "${initial}" requested via options.initialStrategy`,
-    fallbackChain: natural.fallbackChain ?? defaultFallbackChain(initial)
+    fallbackChain
   };
 }
 function strategyToClass(strategy, natural) {