avbridge 2.1.2 → 2.2.0

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",
@@ -32906,6 +33047,9 @@ async function startDecoder(opts) {
   let packetsRead = 0;
   let videoFramesDecoded = 0;
   let audioFramesDecoded = 0;
+  let watchdogFirstFrameMs = 0;
+  let watchdogSlowSinceMs = 0;
+  let watchdogWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
@@ -32917,7 +33061,7 @@ async function startDecoder(opts) {
       let packets;
       try {
         [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
-          limit: 16 * 1024
+          limit: 64 * 1024
         });
       } catch (err) {
         console.error("[avbridge] ff_read_frame_multi failed:", err);
@@ -32934,6 +33078,28 @@ async function startDecoder(opts) {
         await decodeAudioBatch(audioPackets, 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 && !watchdogWarned) {
+          const expectedFrames = elapsedSinceFirst * videoFps;
+          const ratio = videoFramesDecoded / expectedFrames;
+          if (ratio < 0.6) {
+            if (watchdogSlowSinceMs === 0) watchdogSlowSinceMs = performance.now();
+            if ((performance.now() - watchdogSlowSinceMs) / 1e3 > 5) {
+              watchdogWarned = 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;
+          }
+        }
+      }
       while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
         await new Promise((r) => setTimeout(r, 50));
       }
@@ -33260,8 +33426,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);
@@ -33297,12 +33464,26 @@ async function createFallbackSession(ctx, target) {
   }
   async function waitForBuffer() {
     const start = performance.now();
+    dbg.info(
+      "cold-start",
+      `gate entry: need audio >= ${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();
+      if (audioReady && hasFrames) {
+        dbg.info(
+          "cold-start",
+          `gate satisfied in ${(performance.now() - start).toFixed(0)}ms (audio=${(audioAhead * 1e3).toFixed(0)}ms, frames=${renderer.queueDepth()})`
+        );
         return;
       }
       if ((performance.now() - 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). Software decoder is producing output slower than realtime \u2014 playback will stutter. Check getDiagnostics().runtime for the decode rate.`
+        );
         return;
       }
       await new Promise((r) => setTimeout(r, 50));
@@ -33413,8 +33594,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 +33681,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.
@@ -33547,8 +33729,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 +33762,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", {
@@ -33599,6 +33791,14 @@ var UnifiedPlayer = class _UnifiedPlayer {
       this.startTimeupdateLoop();
       this.options.target.addEventListener("ended", () => this.emitter.emit("ended", void 0));
       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);