@torrent-tv/proxy 2.9.93 → 2.9.95

package/services/torrent-worker/piece-reader.js

@@ -26,6 +26,9 @@ import { logger } from "../../utils/logger.js";
 /** Only waits at least this long are reported; sequential reading stays silent. */
 const PIECE_WAIT_LOG_MS = 1_000;
 
+/** Distinguishes concurrent readers to the piece store. Never reused. */
+let readerSequence = 0;
+
 /**
  * How far ahead of the read head pieces are asked for.
  *
@@ -46,22 +49,6 @@ const PIECE_WAIT_LOG_MS = 1_000;
  */
 const READ_WINDOW_BYTES = 32 * 1024 * 1024;
 
-/**
- * How many pieces past the one being waited for are marked critical.
- *
- * `critical` means "a reader is blocked on this now" — it is what lets a piece
- * jump the sequential scan. Marking a whole range critical, as this did, says
- * it about hundreds of pieces at once and the signal stops meaning anything.
- * WebTorrent's own reader marks `min(1 MB / pieceLength, 2)` pieces, i.e. the
- * one under the head and at most two more; the same rule is used here.
- *
- * @param {number} pieceLength
- * @returns {number}
- */
-function criticalRunLength(pieceLength) {
-  return Math.min(Math.floor((1024 * 1024) / Math.max(1, pieceLength)), 2);
-}
-
 /**
  * The pieces a reader at `pieceIndex` wants next, clamped to its own range.
  *
@@ -84,14 +71,16 @@ export function readWindowFor({ pieceIndex, lastPiece, windowPieces }) {
  *
  * @param {import("webtorrent").Torrent} torrent
  * @param {{ from: number, to: number }} window
+ * @param {number} [priority] - 1 for what a reader needs next, 0 for the
+ *   background fill of the rest of the file.
  * @returns {void}
  */
-function claimWindow(torrent, { from, to }) {
+function claimWindow(torrent, { from, to }, priority = 1) {
   try {
     if (typeof torrent._select === "function") {
-      torrent._select(from, to, 1, null, true);
+      torrent._select(from, to, priority, null, true);
     } else if (typeof torrent.select === "function") {
-      torrent.select(from, to, 1);
+      torrent.select(from, to, priority);
     }
   } catch {
     // Best effort — never fail a read because selection bookkeeping refused.
@@ -287,22 +276,120 @@ export async function* readFragments({
   // `bytes 0-<EOF>` left a permanent selection over the entire file, and no
   // later prioritisation could outrank it.
   const windowPieces = Math.max(1, Math.ceil(Math.max(1, windowBytes) / pieceLength));
-  const criticalRun = criticalRunLength(pieceLength);
   /** @type {{ from: number, to: number } | null} */
   let window = null;
   /** @type {{ from: number, to: number } | null} */
   let criticalMark = null;
+  /**
+   * The rest of the file, claimed at the lowest priority so it is fetched with
+   * whatever capacity the near window does not need. Null whenever it must not
+   * be fetched at all — see {@link updateBackfill}.
+   *
+   * @type {{ from: number, to: number } | null}
+   */
+  let backfill = null;
+
+  // Identity of this read, so the store can tell one reader's window from
+  // another's. Each read gets its own; `readerSequence` never repeats within a
+  // process.
+  const readerId = `read-${(readerSequence += 1)}`;
+
+  /**
+   * Whether every piece of the current window is already downloaded.
+   *
+   * A handful of pieces, checked against the bitfield, so this is cheap enough
+   * to re-run on every window move.
+   *
+   * @returns {boolean}
+   */
+  const windowIsComplete = () => {
+    if (!window) {
+      return false;
+    }
+    for (let index = window.from; index <= window.to; index += 1) {
+      if (!torrent.bitfield?.get(index)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Keep the rest of the file downloading in the background, but ONLY while
+   * that cannot cost the viewer anything.
+   *
+   * The rule is deliberately blunt rather than clever: the tail is in the
+   * download set only when every piece of the near window is already on hand.
+   * The moment one is missing — the window slid onto undownloaded content, or a
+   * seek moved it somewhere new — the tail leaves the set, so the swarm has
+   * nothing else to work on. Relying on WebTorrent's priority ordering alone
+   * would be weaker: it decides which selection a wire is offered FIRST, not
+   * what a wire already has outstanding, so a seek would still queue behind
+   * whatever tail blocks were in flight.
+   *
+   * Priority 0 against the window's 1 is kept as well, for the moments between
+   * one evaluation and the next.
+   *
+   * What this buys: a file watched for a while ends up downloaded, and every
+   * later seek into it is instant. What it costs: the pool owner's bandwidth
+   * and disk for a film the viewer may abandon — which is why it never runs
+   * ahead of the viewer's own needs.
+   *
+   * @returns {void}
+   */
+  const updateBackfill = () => {
+    const wanted = window && window.to < lastPiece && windowIsComplete()
+      ? { from: window.to + 1, to: lastPiece }
+      : null;
+    if (backfill && (!wanted || backfill.from !== wanted.from || backfill.to !== wanted.to)) {
+      releaseWindow(torrent, backfill);
+      backfill = null;
+    }
+    if (wanted && !backfill) {
+      claimWindow(torrent, wanted, 0);
+      backfill = wanted;
+    }
+  };
 
   const moveWindowTo = (pieceIndex) => {
     const next = readWindowFor({ pieceIndex, lastPiece, windowPieces });
     if (window && window.from === next.from && window.to === next.to) {
+      updateBackfill();
       return;
     }
+    const isJump = !window || next.from > window.to || next.from < window.from;
+    // Whatever was being fetched for later stops being wanted the instant the
+    // window moves: the new position has to have the whole swarm to itself.
+    if (backfill) {
+      releaseWindow(torrent, backfill);
+      backfill = null;
+    }
     if (window) {
       releaseWindow(torrent, window);
     }
     claimWindow(torrent, next);
     window = next;
+    // Tell the store these pieces are wanted, so it evicts something else.
+    // Without it the piece the decoder reads next looks exactly as stale as one
+    // the encoder fetched forty minutes ahead, and the second kind is what
+    // fills the store while the encoder runs ahead of the viewer.
+    store.protectRange?.(readerId, next.from, next.to);
+    if (isJump) {
+      // A jump — a seek, not the window sliding along — can land on pieces that
+      // are already downloaded but have been spilled to disk. Bring the whole
+      // window back at once instead of one disk round trip per piece as the
+      // reader reaches them.
+      const revived = store.warmRange?.(next.from, next.to) ?? 0;
+      if (revived > 0) {
+        logger.info(
+          `piece-reader: reviving ${revived} spilled piece(s) of ${next.from}-${next.to} ` +
+            `for a jump to ${(start / 1024 / 1024).toFixed(0)}MB of "${file.name}"`
+        );
+      }
+    }
+    // Only now, with the new window claimed and marked, may anything else be
+    // asked for — and only if the window needs nothing.
+    updateBackfill();
   };
 
   try {
@@ -318,8 +405,19 @@ export async function* readFragments({
       moveWindowTo(pieceIndex);
 
       if (!torrent.bitfield?.get(pieceIndex)) {
-        // Blocked here and now — this is the one case `critical` is meant for.
-        criticalMark = markCritical(torrent, pieceIndex, Math.min(lastPiece, pieceIndex + criticalRun), criticalMark);
+        // Everything from here to the end of the window is wanted NOW, so all
+        // of it is marked, not just the piece under the head. `critical`
+        // enables hotswap: a block reserved by a slow peer is re-requested from
+        // a faster one instead of holding up the reader. Measured 2026-08-04
+        // with only the blocked piece marked, the first segment after a seek
+        // took 7.2 s while its four 4 MB pieces arrived one after another at
+        // ~2.2 MB/s, with waits of 1.3 s and 2.8 s on single pieces.
+        //
+        // This is not the old behaviour returning: that marked the whole
+        // REQUESTED RANGE, which for ffmpeg's input means every piece to the
+        // end of the file — hundreds of them, at which point the flag says
+        // nothing. A window is what a reader genuinely needs next.
+        criticalMark = markCritical(torrent, pieceIndex, window.to, criticalMark);
       }
 
       const waitStartedAt = Date.now();
@@ -372,9 +470,13 @@ export async function* readFragments({
     // Reached on completion, on cancellation, on a throw, and when the consumer
     // stops iterating — a window left behind would keep the swarm fetching for
     // a reader that no longer exists.
+    if (backfill) {
+      releaseWindow(torrent, backfill);
+    }
     if (window) {
       releaseWindow(torrent, window);
     }
+    store.releaseProtection?.(readerId);
     if (criticalMark) {
       clearCritical(torrent, criticalMark);
     }