avbridge 2.11.0 → 2.12.1

package/dist/element-browser.js

@@ -29513,7 +29513,8 @@ async function prepareLibavInput(libav, filename, source, transport) {
   if (source.kind === "url") {
     const handle = await attachLibavHttpReader(libav, filename, source.url, {
       requestInit: transport?.requestInit,
-      fetchFn: transport?.fetchFn
+      fetchFn: transport?.fetchFn,
+      cacheBytes: transport?.cacheBytes
     });
     return {
       filename,
@@ -29575,7 +29576,9 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
   }
   await libav.mkblockreaderdev(filename, size);
   let detached = false;
-  let cached = null;
+  const cache2 = /* @__PURE__ */ new Map();
+  let cacheBytes = 0;
+  const cacheBudget = Math.max(0, options.cacheBytes ?? DEFAULT_CACHE_BYTES);
   let inflight = null;
   function clampReadLength(requested) {
     const doubled = requested * 2;
@@ -29583,14 +29586,33 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
     if (doubled > MAX_READ) return MAX_READ;
     return doubled;
   }
-  function cacheCovers(pos, length) {
-    if (!cached) return false;
-    return pos >= cached.pos && pos + length <= cached.pos + cached.bytes.byteLength;
+  function cacheLookup(pos, length) {
+    for (const [blockPos, bytes2] of cache2) {
+      if (pos >= blockPos && pos + length <= blockPos + bytes2.byteLength) {
+        cache2.delete(blockPos);
+        cache2.set(blockPos, bytes2);
+        const offset = pos - blockPos;
+        return bytes2.subarray(offset, offset + length);
+      }
+    }
+    return null;
   }
-  function sliceFromCache(pos, length) {
-    if (!cached) throw new Error("sliceFromCache called with no cache");
-    const offset = pos - cached.pos;
-    return cached.bytes.subarray(offset, offset + length);
+  function cacheInsert(pos, bytes2) {
+    const existing = cache2.get(pos);
+    if (existing) {
+      cacheBytes -= existing.byteLength;
+      cache2.delete(pos);
+    }
+    cache2.set(pos, bytes2);
+    cacheBytes += bytes2.byteLength;
+    while (cacheBytes > cacheBudget && cache2.size > 0) {
+      const oldestKey = cache2.keys().next().value;
+      if (oldestKey === void 0) break;
+      const oldest = cache2.get(oldestKey);
+      if (!oldest) break;
+      cache2.delete(oldestKey);
+      cacheBytes -= oldest.byteLength;
+    }
   }
   async function fetchRange(pos, length) {
     const end = Math.min(pos + length - 1, size - 1);
@@ -29607,7 +29629,7 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
       );
     }
     const buf = new Uint8Array(await res.arrayBuffer());
-    cached = { pos, bytes: buf };
+    cacheInsert(pos, buf);
     return buf;
   }
   async function handleRead(name, pos, length) {
@@ -29618,10 +29640,10 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
       }
     }
     if (detached) return;
-    if (cacheCovers(pos, length)) {
-      const data = sliceFromCache(pos, length);
+    const hit = cacheLookup(pos, length);
+    if (hit) {
       try {
-        await libav.ff_block_reader_dev_send(name, pos, data);
+        await libav.ff_block_reader_dev_send(name, pos, hit);
       } catch {
       }
       return;
@@ -29674,7 +29696,8 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
         } catch {
         }
       }
-      cached = null;
+      cache2.clear();
+      cacheBytes = 0;
       try {
         await libav.unlinkreadaheadfile(filename);
       } catch {
@@ -29682,11 +29705,12 @@ async function attachLibavHttpReader(libav, filename, url2, options = {}) {
     }
   };
 }
-var MIN_READ, MAX_READ;
+var MIN_READ, MAX_READ, DEFAULT_CACHE_BYTES;
 var init_libav_http_reader = __esm({
   "src/util/libav-http-reader.ts"() {
     MIN_READ = 256 * 1024;
     MAX_READ = 1 * 1024 * 1024;
+    DEFAULT_CACHE_BYTES = 8 * 1024 * 1024;
   }
 });
 
@@ -29933,7 +29957,7 @@ async function probeWithLibav(source, sniffed) {
         codec: ffmpegToAvbridgeVideo(codecName),
         width: codecpar?.width ?? 0,
         height: codecpar?.height ?? 0,
-        fps: framerate(stream)
+        fps: await framerate(libav, stream)
       });
     } else if (stream.codec_type === libav.AVMEDIA_TYPE_AUDIO) {
       audioTracks.push({
@@ -29961,7 +29985,7 @@ async function probeWithLibav(source, sniffed) {
     duration
   };
 }
-function framerate(stream) {
+async function framerate(libav, stream) {
   if (typeof stream.avg_frame_rate_num === "number" && stream.avg_frame_rate_den) {
     return stream.avg_frame_rate_num / stream.avg_frame_rate_den;
   }
@@ -29969,6 +29993,14 @@ function framerate(stream) {
     if (stream.avg_frame_rate.den === 0) return void 0;
     return stream.avg_frame_rate.num / stream.avg_frame_rate.den;
   }
+  try {
+    const num = await libav.AVCodecParameters_framerate_num?.(stream.codecpar);
+    const den = await libav.AVCodecParameters_framerate_den?.(stream.codecpar);
+    if (typeof num === "number" && typeof den === "number" && den > 0 && num > 0) {
+      return num / den;
+    }
+  } catch {
+  }
   return void 0;
 }
 async function safeDuration(libav, fmt_ctx) {
@@ -32537,10 +32569,20 @@ var VideoRenderer = class {
   /** Resolves once the first decoded frame has been enqueued. */
   firstFrameReady;
   resolveFirstFrame;
-  /** True once at least one frame has been enqueued. */
+  /**
+   * True once at least one frame has been enqueued *since the last flush*.
+   * Used by `readyState` — initial cold-start reports HAVE_NOTHING until
+   * any frame has arrived, and after a seek we want the same semantics
+   * (HAVE_NOTHING until post-seek frames arrive), so the cumulative
+   * `framesPainted > 0` that used to live here was wrong: it kept the
+   * state "true forever" after the first frame ever, so post-seek
+   * `waitForBuffer()` would exit immediately with an empty queue and
+   * leave video frozen while audio kept going.
+   */
   hasFrames() {
-    return this.queue.length > 0 || this.framesPainted > 0;
+    return this.queue.length > 0 || this.hasEverEnqueuedSinceFlush;
   }
+  hasEverEnqueuedSinceFlush = false;
   /** Current depth of the frame queue. Used by the decoder for backpressure. */
   queueDepth() {
     return this.queue.length;
@@ -32559,6 +32601,7 @@ var VideoRenderer = class {
       return;
     }
     this.queue.push(frame);
+    this.hasEverEnqueuedSinceFlush = true;
     if (this.queue.length === 1 && this.framesPainted === 0) {
       this.resolveFirstFrame();
     }
@@ -32692,7 +32735,8 @@ var VideoRenderer = class {
         }
         return;
       }
-      const dropThresholdUs = audioNowUs - frameDurationUs * 2;
+      const _relaxDrop = globalThis.AVBRIDGE_RELAX_DROP === true;
+      const dropThresholdUs = _relaxDrop ? audioNowUs - 60 * 1e6 : audioNowUs - frameDurationUs * 2;
       let dropped = 0;
       while (bestIdx > 0) {
         const ts = this.queue[0].timestamp ?? 0;
@@ -32753,16 +32797,28 @@ var VideoRenderer = class {
     while (this.queue.length > 0) this.queue.shift()?.close();
     this.prerolled = false;
     this.ptsCalibrated = false;
+    this.hasEverEnqueuedSinceFlush = false;
     if (isDebug() && count > 0) {
       console.log(`[avbridge:renderer] FLUSH discarded=${count} painted=${this.framesPainted} drops=${this.framesDroppedLate}`);
     }
   }
   stats() {
+    let queueSpanMs = 0;
+    let queueHeadMs = 0;
+    let queueTailMs = 0;
+    if (this.queue.length > 0) {
+      queueHeadMs = Math.round((this.queue[0].timestamp ?? 0) / 1e3);
+      queueTailMs = Math.round((this.queue[this.queue.length - 1].timestamp ?? 0) / 1e3);
+      queueSpanMs = Math.max(0, queueTailMs - queueHeadMs);
+    }
     return {
       framesPainted: this.framesPainted,
       framesDroppedLate: this.framesDroppedLate,
       framesDroppedOverflow: this.framesDroppedOverflow,
-      queueDepth: this.queue.length
+      queueDepth: this.queue.length,
+      queueHeadMs,
+      queueTailMs,
+      queueSpanMs
     };
   }
   destroy() {
@@ -33304,6 +33360,7 @@ async function startHybridDecoder(opts) {
   }
   let bsfCtx = null;
   let bsfPkt = null;
+  let bsfRequiredButMissing = false;
   if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
     try {
       bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
@@ -33314,13 +33371,19 @@ async function startHybridDecoder(opts) {
         bsfPkt = await libav.av_packet_alloc();
         dbg.info("bsf", "mpeg4_unpack_bframes BSF active (hybrid)");
       } else {
-        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available in hybrid decoder");
+        bsfRequiredButMissing = true;
         bsfCtx = null;
       }
     } catch (err) {
-      console.warn("[avbridge] hybrid: failed to init BSF:", err.message);
+      bsfRequiredButMissing = true;
       bsfCtx = null;
       bsfPkt = null;
+      dbg.warn("bsf", `hybrid: mpeg4_unpack_bframes BSF init failed: ${err.message}`);
+    }
+    if (bsfRequiredButMissing) {
+      console.error(
+        "[avbridge] MPEG-4 Part 2 (DivX/Xvid) detected but mpeg4_unpack_bframes BSF is unavailable in this libav variant. Files with packed B-frames will play with incorrect frame ordering. Rebuild the libav variant with the `avbsf` fragment included."
+      );
     }
   }
   async function applyBSF(packets) {
@@ -33330,7 +33393,6 @@ async function startHybridDecoder(opts) {
       await libav.ff_copyin_packet(bsfPkt, pkt);
       const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
       if (sendErr < 0) {
-        out.push(pkt);
         continue;
       }
       while (true) {
@@ -33344,10 +33406,13 @@ async function startHybridDecoder(opts) {
   async function flushBSF() {
     if (!bsfCtx || !bsfPkt) return;
     try {
-      await libav.av_bsf_send_packet(bsfCtx, 0);
-      while (true) {
-        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
-        if (err < 0) break;
+      if (libav.av_bsf_flush) {
+        await libav.av_bsf_flush(bsfCtx);
+      } else {
+        while (true) {
+          const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+          if (err < 0) break;
+        }
       }
     } catch {
     }
@@ -33659,6 +33724,7 @@ async function startHybridDecoder(opts) {
         videoChunksFed,
         audioFramesDecoded,
         bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
+        bsfMissing: bsfRequiredButMissing ? ["mpeg4_unpack_bframes"] : [],
         videoDecodeQueueSize: videoDecoder?.decodeQueueSize ?? 0,
         // Confirmed transport info — see fallback decoder for the pattern.
         _transport: inputHandle.transport === "http-range" ? "http-range" : "memory",
@@ -33960,6 +34026,7 @@ async function startDecoder(opts) {
   }
   let bsfCtx = null;
   let bsfPkt = null;
+  let bsfRequiredButMissing = false;
   if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
     try {
       bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
@@ -33970,13 +34037,19 @@ async function startDecoder(opts) {
         bsfPkt = await libav.av_packet_alloc();
         dbg.info("bsf", "mpeg4_unpack_bframes BSF active");
       } else {
-        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available \u2014 decoding without it");
+        bsfRequiredButMissing = true;
         bsfCtx = null;
       }
     } catch (err) {
-      console.warn("[avbridge] failed to init mpeg4_unpack_bframes BSF:", err.message);
+      bsfRequiredButMissing = true;
       bsfCtx = null;
       bsfPkt = null;
+      dbg.warn("bsf", `mpeg4_unpack_bframes BSF init failed: ${err.message}`);
+    }
+    if (bsfRequiredButMissing) {
+      console.error(
+        "[avbridge] MPEG-4 Part 2 (DivX/Xvid) detected but mpeg4_unpack_bframes BSF is unavailable in this libav variant. Files with packed B-frames will play with incorrect frame ordering (backwards PTS jumps, heavy late-drop stuttering). Rebuild the libav variant with the `avbsf` fragment included. See docs/dev/POSTMORTEMS.md for details."
+      );
     }
   }
   async function applyBSF(packets) {
@@ -33986,7 +34059,6 @@ async function startDecoder(opts) {
       await libav.ff_copyin_packet(bsfPkt, pkt);
       const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
       if (sendErr < 0) {
-        out.push(pkt);
         continue;
       }
       while (true) {
@@ -34000,10 +34072,13 @@ async function startDecoder(opts) {
   async function flushBSF() {
     if (!bsfCtx || !bsfPkt) return;
     try {
-      await libav.av_bsf_send_packet(bsfCtx, 0);
-      while (true) {
-        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
-        if (err < 0) break;
+      if (libav.av_bsf_flush) {
+        await libav.av_bsf_flush(bsfCtx);
+      } else {
+        while (true) {
+          const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+          if (err < 0) break;
+        }
       }
     } catch {
     }
@@ -34021,6 +34096,19 @@ async function startDecoder(opts) {
   let watchdogOverflowWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
+  let videoDecodeMsTotal = 0;
+  let audioDecodeMsTotal = 0;
+  let videoDecodeBatches = 0;
+  let audioDecodeBatches = 0;
+  let readMsTotal = 0;
+  let readBatches = 0;
+  let pumpThrottleMsTotal = 0;
+  let pumpThrottleEntries = 0;
+  let slowestVideoBatchMs = 0;
+  let newestVideoPtsUs = 0;
+  let lastEmittedPtsUs = -1;
+  let ptsRegressions = 0;
+  let worstPtsRegressionMs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
   const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
   const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
@@ -34029,9 +34117,12 @@ async function startDecoder(opts) {
       let readErr;
       let packets;
       try {
+        const _readStart = performance.now();
         [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
           limit: 16 * 1024
         });
+        readMsTotal += performance.now() - _readStart;
+        readBatches++;
       } catch (err) {
         console.error("[avbridge] ff_read_frame_multi failed:", err);
         return;
@@ -34093,8 +34184,17 @@ async function startDecoder(opts) {
           }
         }
       }
-      while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
-        await new Promise((r) => setTimeout(r, 50));
+      {
+        const _throttleStart = performance.now();
+        let _throttled = false;
+        while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
+          _throttled = true;
+          await new Promise((r) => setTimeout(r, 50));
+        }
+        if (_throttled) {
+          pumpThrottleMsTotal += performance.now() - _throttleStart;
+          pumpThrottleEntries++;
+        }
       }
       if (readErr === libav.AVERROR_EOF) {
         if (videoDec) await decodeVideoBatch(
@@ -34120,6 +34220,7 @@ async function startDecoder(opts) {
   async function decodeVideoBatch(pkts, myToken, flush = false) {
     if (!videoDec || destroyed || myToken !== pumpToken) return;
     let frames;
+    const _t0 = performance.now();
     try {
       frames = await libav.ff_decode_multi(
         videoDec.c,
@@ -34132,18 +34233,38 @@ async function startDecoder(opts) {
       console.error("[avbridge] video decode batch failed:", err);
       return;
     }
+    {
+      const _dt = performance.now() - _t0;
+      videoDecodeMsTotal += _dt;
+      videoDecodeBatches++;
+      if (_dt > slowestVideoBatchMs) slowestVideoBatchMs = _dt;
+    }
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
       sanitizeFrameTimestamp(
         f,
         () => {
-          const ts = syntheticVideoUs;
-          syntheticVideoUs += videoFrameStepUs;
-          return ts;
+          const base = lastEmittedPtsUs >= 0 ? lastEmittedPtsUs + videoFrameStepUs : syntheticVideoUs;
+          syntheticVideoUs = base + videoFrameStepUs;
+          return base;
         },
         videoTimeBase
       );
+      const _fPts = (f.ptshi ?? 0) * 4294967296 + (f.pts ?? 0);
+      if (_fPts > newestVideoPtsUs) newestVideoPtsUs = _fPts;
+      if (lastEmittedPtsUs >= 0 && _fPts < lastEmittedPtsUs) {
+        ptsRegressions++;
+        const regressMs = (lastEmittedPtsUs - _fPts) / 1e3;
+        if (regressMs > worstPtsRegressionMs) worstPtsRegressionMs = regressMs;
+        if (ptsRegressions <= 10) {
+          console.warn(
+            `[avbridge:decoder] dropped out-of-order frame #${ptsRegressions}: pts=${(_fPts / 1e3).toFixed(1)}ms < previous=${(lastEmittedPtsUs / 1e3).toFixed(1)}ms (regression=${regressMs.toFixed(1)}ms). Typically a post-seek B-frame reorder tail.`
+          );
+        }
+        continue;
+      }
+      lastEmittedPtsUs = _fPts;
       try {
         const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
         opts.renderer.enqueue(vf);
@@ -34158,6 +34279,7 @@ async function startDecoder(opts) {
   async function decodeAudioBatch(pkts, myToken, flush = false) {
     if (!audioDec || destroyed || myToken !== pumpToken) return;
     let frames;
+    const _t0 = performance.now();
     try {
       frames = await libav.ff_decode_multi(
         audioDec.c,
@@ -34170,6 +34292,8 @@ async function startDecoder(opts) {
       console.error("[avbridge] audio decode batch failed:", err);
       return;
     }
+    audioDecodeMsTotal += performance.now() - _t0;
+    audioDecodeBatches++;
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
@@ -34291,6 +34415,7 @@ async function startDecoder(opts) {
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastEmittedPtsUs = -1;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] fallback pump failed (post-setAudioTrack):", err)
       );
@@ -34328,6 +34453,7 @@ async function startDecoder(opts) {
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastEmittedPtsUs = -1;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] decoder pump failed (post-seek):", err)
       );
@@ -34341,7 +34467,24 @@ async function startDecoder(opts) {
         packetsRead,
         videoFramesDecoded,
         audioFramesDecoded,
+        // Throughput instrumentation — the stats panel turns these into
+        // "decode fps actual / realtime target" and shows slowest batch
+        // + producer throttle share.
+        videoDecodeMsTotal,
+        videoDecodeBatches,
+        audioDecodeMsTotal,
+        audioDecodeBatches,
+        readMsTotal,
+        readBatches,
+        pumpThrottleMsTotal,
+        pumpThrottleEntries,
+        slowestVideoBatchMs,
+        newestVideoPtsMs: Math.round(newestVideoPtsUs / 1e3),
+        ptsRegressions,
+        worstPtsRegressionMs,
+        sourceFps: videoFps,
         bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
+        bsfMissing: bsfRequiredButMissing ? ["mpeg4_unpack_bframes"] : [],
         // Confirmed transport info: once prepareLibavInput returns
         // successfully, we *know* whether the source is http-range (probe
         // succeeded and returned 206) or in-memory blob. Diagnostics hoists
@@ -34634,9 +34777,9 @@ var UnifiedPlayer = class _UnifiedPlayer {
   constructor(options, registry) {
     this.options = options;
     this.registry = registry;
-    const { requestInit, fetchFn } = options;
-    if (requestInit || fetchFn) {
-      this.transport = { requestInit, fetchFn };
+    const { requestInit, fetchFn, cacheBytes } = options;
+    if (requestInit || fetchFn || cacheBytes !== void 0) {
+      this.transport = { requestInit, fetchFn, cacheBytes };
     }
   }
   options;