@torrent-tv/proxy 2.107.51 → 2.107.53

package/services/torrent/download/TailRepeat.js

@@ -0,0 +1,155 @@
+/**
+ * @file Decide when a second copy of a late missing block is useful.
+ *
+ * WebTorrent normally owns picking, queues and request reassignment. This
+ * exception is bounded to the currently required urgent pieces, a tail of at
+ * most 16 missing blocks, requests older than one wire queue, and two copies
+ * per block. The injected adapter is the only place that touches WebTorrent's
+ * private piece/reservation/request state.
+ */
+
+/** `PIPELINE_MAX_DURATION`: WebTorrent sizes each wire queue to one second. */
+const WIRE_QUEUE_MS = 1000;
+const SHORT_TAIL_BLOCKS = 16;
+const MAX_COPIES = 2;
+
+export class TailRepeat {
+  #requiredPieces;
+  #adapter;
+  #schedule;
+  #wake;
+  #clear;
+  #scheduled = false;
+  #timer = null;
+  #timerAt = Number.POSITIVE_INFINITY;
+  #disposed = false;
+  #unwatch;
+  #log;
+  #now;
+  #reportedUnavailable = false;
+
+  /**
+   * @param {object} params
+   * @param {() => Array<{ from: number, to: number }>} params.requiredPieces
+   * @param {{ observe: Function, repeatBlock: Function, watch: Function }} params.adapter
+   * @param {(work: () => void) => void} [params.schedule]
+   * @param {(work: () => void, ms: number) => unknown} [params.wake]
+   * @param {(handle: unknown) => void} [params.clear]
+   * @param {(line: string) => void} [params.log]
+   * @param {() => number} [params.now]
+   */
+  constructor({ requiredPieces, adapter, schedule = setImmediate, wake = setTimeout, clear = clearTimeout, log = null, now = Date.now }) {
+    this.#requiredPieces = requiredPieces;
+    this.#adapter = adapter;
+    this.#schedule = schedule;
+    this.#wake = wake;
+    this.#clear = clear;
+    this.#log = log;
+    this.#now = now;
+    this.totals = { duplicated: 0, looks: 0, lateBlocks: 0 };
+    try {
+      this.#unwatch = adapter.watch(() => this.poke(), () => { this.totals.lateBlocks += 1; });
+    } catch {
+      this.#reportUnavailable();
+      this.#unwatch = null;
+    }
+  }
+
+  /** Look at the tails once this turn of the event loop is over. */
+  poke() {
+    if (this.#scheduled || this.#disposed) return;
+    this.#scheduled = true;
+    this.#schedule(() => this.#look());
+  }
+
+  /** Stop watching and cancel the one armed age check. */
+  dispose() {
+    this.#disposed = true;
+    this.#unwatch?.();
+    this.#unwatch = null;
+    if (this.#timer !== null) this.#clear(this.#timer);
+    this.#timer = null;
+  }
+
+  #lookAgainAt(at, now) {
+    if (!Number.isFinite(at) || at >= this.#timerAt || this.#disposed) return;
+    if (this.#timer !== null) this.#clear(this.#timer);
+    this.#timerAt = at;
+    this.#timer = this.#wake(() => {
+      this.#timer = null;
+      this.#timerAt = Number.POSITIVE_INFINITY;
+      this.poke();
+    }, Math.max(0, at - now));
+    this.#timer?.unref?.();
+  }
+
+  #look() {
+    this.#scheduled = false;
+    if (this.#disposed) return;
+    this.totals.looks += 1;
+    const now = this.#now();
+    let dueAt = Number.POSITIVE_INFINITY;
+    let unplaced = 0;
+    const asked = [];
+
+    for (const { from, to } of this.#requiredPieces()) {
+      for (let pieceIndex = from; pieceIndex <= to; pieceIndex += 1) {
+        if (this.#disposed) return;
+        let observation;
+        try {
+          observation = this.#adapter.observe(pieceIndex, SHORT_TAIL_BLOCKS);
+        } catch {
+          this.#reportUnavailable();
+          continue;
+        }
+        if (!observation?.available) {
+          this.#reportUnavailable();
+          continue;
+        }
+        if (observation.missingCount === 0 || observation.missingCount > SHORT_TAIL_BLOCKS) continue;
+
+        let pieceCopies = 0;
+        for (const block of observation.blocks) {
+          if (block.copies === 0 || block.copies >= MAX_COPIES) continue;
+          const firstAskedAt = block.firstAskedAt ?? Number.NEGATIVE_INFINITY;
+          if (now - firstAskedAt < WIRE_QUEUE_MS) {
+            dueAt = Math.min(dueAt, firstAskedAt + WIRE_QUEUE_MS);
+            continue;
+          }
+          let result;
+          try {
+            result = this.#adapter.repeatBlock(pieceIndex, block.index);
+          } catch {
+            this.#reportUnavailable();
+            continue;
+          }
+          if (result === "unavailable") {
+            this.#reportUnavailable();
+            continue;
+          }
+          if (result === "placed") {
+            pieceCopies += 1;
+            this.totals.duplicated += 1;
+          } else {
+            unplaced += 1;
+          }
+        }
+        if (pieceCopies > 0) asked.push(`${pieceIndex}:${pieceCopies}/${observation.missingCount}`);
+      }
+    }
+
+    if (asked.length > 0) {
+      this.#log?.(`tail: asked a second peer for the last blocks of piece:blocks/missing ${asked.join(" ")}; ` +
+        `${this.totals.duplicated} block copies asked so far, ${this.totals.lateBlocks} block(s) arrived after their piece was complete`);
+    }
+    if (unplaced > 0) dueAt = Math.min(dueAt, now + WIRE_QUEUE_MS);
+    this.#lookAgainAt(dueAt, now);
+  }
+
+  #reportUnavailable() {
+    if (this.#reportedUnavailable) return;
+    this.#reportedUnavailable = true;
+    this.#adapter.disable?.();
+    this.#log?.("tail: bounded repeat unavailable; using WebTorrent's ordinary picker");
+  }
+}

package/services/torrent/torrent-pool.js

@@ -25,14 +25,15 @@ import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zone
 import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
 import { PieceTimings, describePieceTiming } from "./piece-timing.js";
-import { TailRepeat } from "./worker/tail-repeat.js";
+import { TailRepeat } from "./download/TailRepeat.js";
+import { WebTorrentTailRepeatAdapter } from "./worker/WebTorrentTailRepeatAdapter.js";
 import { tracePieceStorePut } from "./worker/trace-piece-store-put.js";
 import { beginSwarmLifecycleTrace, noteSwarmDiscovery, noteSwarmMetadata, noteSwarmPeer } from "./worker/trace-swarm-lifecycle.js";
 
 /**
  * The second-peer requests for the last blocks of a piece somebody waits for,
  * one per torrent, made when the torrent is first watched and stopped when it
- * is forgotten (`worker/tail-repeat.js`).
+ * is forgotten (`download/TailRepeat.js`).
  *
  * @type {WeakMap<object, TailRepeat>}
  */
@@ -1901,7 +1902,8 @@ export class TorrentPool {
     // per piece: a 2.3 GB film is 563.
     const timings = new PieceTimings();
     const waitTracePieceStarts = new Map();
-    tailRepeats.set(torrent, new TailRepeat({ torrent, requiredPieces: () => demandFor(torrent).selection.requiredPieces(),
+    tailRepeats.set(torrent, new TailRepeat({ adapter: new WebTorrentTailRepeatAdapter(torrent),
+      requiredPieces: () => demandFor(torrent).selection.requiredPieces(),
       log: (line) => logger.info(`download ${label()} ${line}`) }));
     torrent.on("wire", (wire) => {
       // WebTorrent asks a wire for a block by calling `request` and states
@@ -1922,7 +1924,7 @@ export class TorrentPool {
             trace("W8", "begin", { piece: index, startedAt, firstOffset: offset, blockLength: length });
           }
           // When this wire was asked for the block: how long it has held it is
-          // what decides whether a second peer is asked (`duplicateTailFor`).
+          // what decides whether a second peer is asked (download/TailRepeat).
           this.requests.at(-1).askedAt = now;
         }
         return answer;

package/services/torrent/worker/WebTorrentTailRepeatAdapter.js

@@ -0,0 +1,216 @@
+/**
+ * @file The narrow WebTorrent 2.8.5 adapter used by torrent/download/TailRepeat.
+ *
+ * This is the only live caller allowed to inspect piece buffers and wire
+ * queues, or to touch Piece.cancel/reserve and Torrent._request for bounded
+ * late-tail repetition. Keep library-private assumptions here and update the
+ * compatibility check when the pinned WebTorrent/torrent-piece pair changes.
+ */
+
+const BLOCK_BYTES = 1 << 14;
+
+function speedOf(wire) {
+  try {
+    const speed = wire?.downloadSpeed?.();
+    return Number.isFinite(speed) ? speed : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function usableWires(torrent, pieceIndex) {
+  const wires = Array.isArray(torrent?.wires) ? torrent.wires : [];
+  return wires.filter((wire) => {
+    // WebTorrent's _request uses reserveRemaining/chunkLengthRemaining for a
+    // webseed, which requests the piece suffix rather than one bounded block.
+    if (!wire || wire.type === "webSeed" || wire.destroyed || wire.peerChoking) return false;
+    try {
+      return wire.peerPieces?.get?.(pieceIndex) === true;
+    } catch {
+      return false;
+    }
+  }).sort((left, right) => speedOf(right) - speedOf(left));
+}
+
+function requestCoversBlock(request, pieceIndex, blockIndex, chunks) {
+  if (request?.piece !== pieceIndex || !Number.isFinite(request.offset) || request.offset < 0) return false;
+  const firstBlock = Math.floor(request.offset / BLOCK_BYTES);
+  // A request without a length is an incompatible observation. Count it
+  // conservatively through the piece's end rather than allowing extra copies.
+  const lastBlock = Number.isFinite(request.length) && request.length > 0
+    ? Math.min(chunks - 1, Math.ceil((request.offset + request.length) / BLOCK_BYTES) - 1)
+    : chunks - 1;
+  return blockIndex >= firstBlock && blockIndex <= lastBlock;
+}
+
+/**
+ * Adapts a live WebTorrent Torrent to the small observation/action contract
+ * needed by TailRepeat. It does not choose which piece or block to repeat.
+ */
+export class WebTorrentTailRepeatAdapter {
+  #torrent;
+  #disabled = false;
+
+  /** @param {object} torrent A WebTorrent Torrent instance. */
+  constructor(torrent) {
+    this.#torrent = torrent;
+  }
+
+  /** Disable the exception after an incompatible private API is observed. */
+  disable() {
+    this.#disabled = true;
+  }
+
+  /**
+   * Read missing blocks and their in-flight copy count/age.
+   *
+   * @param {number} pieceIndex
+   * @param {number} maxMissing Upper bound supplied by the download policy; a
+   *   larger tail is reported by count without allocating a per-block list.
+   * @returns {{ available: boolean, missingCount: number, blocks: Array<{ index: number, copies: number, firstAskedAt: number|null }> }}
+   */
+  observe(pieceIndex, maxMissing) {
+    const torrent = this.#torrent;
+    const piece = torrent?.pieces?.[pieceIndex];
+    // Completed pieces are removed from Torrent.pieces; a piece with no
+    // allocated block buffer has no request in flight, so neither is a tail.
+    if (!piece) return { available: true, missingCount: 0, blocks: [] };
+    const buffer = Array.isArray(piece?._buffer) ? piece._buffer : null;
+    if (!buffer) return { available: true, missingCount: 0, blocks: [] };
+    if (this.#disabled || typeof piece.cancel !== "function" || typeof torrent?._request !== "function") {
+      this.#disabled = true;
+      return { available: false, missingCount: 0, blocks: [] };
+    }
+
+    const chunks = Number.isFinite(piece._chunks) ? piece._chunks : buffer.length;
+    let missingCount = Number.isFinite(piece._buffered) ? chunks - piece._buffered : 0;
+    if (!Number.isFinite(piece._buffered)) {
+      for (let index = 0; index < chunks; index += 1) if (!buffer[index]) missingCount += 1;
+    }
+    if (missingCount === 0 || missingCount > maxMissing) {
+      return { available: true, missingCount, blocks: [] };
+    }
+
+    const blocks = [];
+    for (let index = 0; index < chunks; index += 1) {
+      if (buffer[index]) continue;
+      blocks.push({ index, copies: 0, firstAskedAt: null });
+    }
+    for (const wire of Array.isArray(torrent.wires) ? torrent.wires : []) {
+      for (const request of Array.isArray(wire?.requests) ? wire.requests : []) {
+        for (const block of blocks) {
+          if (!requestCoversBlock(request, pieceIndex, block.index, chunks)) continue;
+          block.copies += 1;
+          const askedAt = Number.isFinite(request.askedAt) ? request.askedAt : Number.NEGATIVE_INFINITY;
+          block.firstAskedAt = block.firstAskedAt === null ? askedAt : Math.min(block.firstAskedAt, askedAt);
+        }
+      }
+    }
+    return { available: true, missingCount, blocks };
+  }
+
+  /**
+   * Try one repeat for an already-selected, already-aged missing block.
+   * Returns a status instead of throwing so an incompatible private API cannot
+   * stop ordinary downloading. Every refusal restores the reservation.
+   *
+   * @param {number} pieceIndex
+   * @param {number} blockIndex
+   * @returns {"placed"|"refused"|"unavailable"}
+   */
+  repeatBlock(pieceIndex, blockIndex) {
+    const torrent = this.#torrent;
+    const piece = torrent?.pieces?.[pieceIndex];
+    const buffer = Array.isArray(piece?._buffer) ? piece._buffer : null;
+    if (this.#disabled || !piece || !buffer || buffer[blockIndex] || typeof piece.cancel !== "function" ||
+        typeof piece.reserve !== "function" || typeof torrent?._request !== "function") {
+      return "unavailable";
+    }
+
+    const candidates = usableWires(torrent, pieceIndex);
+    const chunks = Number.isFinite(piece._chunks) ? piece._chunks : buffer.length;
+    if (candidates.length === 0) return "refused";
+
+    for (const wire of candidates) {
+      if ((wire.requests ?? []).some((request) => requestCoversBlock(request, pieceIndex, blockIndex, chunks))) continue;
+
+      try {
+        piece.cancel(blockIndex);
+      } catch {
+        this.#disabled = true;
+        return "unavailable";
+      }
+
+      let placed = false;
+      try {
+        // false prevents WebTorrent's hotswap from freeing a third reservation.
+        placed = torrent._request(wire, pieceIndex, false) === true;
+      } catch {
+        // A thrown private call may have queued the request before failing.
+        placed = (wire.requests ?? []).some((request) => request?.piece === pieceIndex &&
+          Math.floor(request.offset / BLOCK_BYTES) === blockIndex);
+        if (!placed) {
+          try {
+            if (piece.reserve() !== blockIndex) this.#disabled = true;
+          } catch { this.#disabled = true; }
+        }
+        this.#disabled = true;
+        return placed ? "placed" : "unavailable";
+      }
+      if (placed) return "placed";
+
+      // _request refused before reserving. Claim the freed block back so the
+      // normal picker cannot see an unaccounted reservation.
+      try {
+        if (piece.reserve() !== blockIndex) {
+          this.#disabled = true;
+          return "unavailable";
+        }
+      } catch {
+        this.#disabled = true;
+        return "unavailable";
+      }
+    }
+    return "refused";
+  }
+
+  /** Subscribe to changes that can alter tail observations. */
+  watch(onChange, onLateBlock = () => {}) {
+    const torrent = this.#torrent;
+    const watched = new Map();
+    const poke = () => onChange();
+    const forget = (wire) => {
+      const listeners = watched.get(wire);
+      if (!listeners) return;
+      wire.removeListener?.("piece", listeners.onBlock);
+      for (const event of ["unchoke", "have", "bitfield"]) wire.removeListener?.(event, listeners.onPeer);
+      wire.removeListener?.("close", listeners.onClose);
+      watched.delete(wire);
+    };
+    const watchWire = (wire) => {
+      if (!wire || watched.has(wire) || typeof wire.on !== "function") return;
+      const listeners = {
+        onBlock: (index) => {
+          if (Number.isInteger(index) && torrent.bitfield?.get?.(index)) onLateBlock();
+          poke();
+        },
+        onPeer: poke,
+        onClose: () => { forget(wire); poke(); }
+      };
+      watched.set(wire, listeners);
+      wire.on("piece", listeners.onBlock);
+      for (const event of ["unchoke", "have", "bitfield"]) wire.on(event, listeners.onPeer);
+      wire.once?.("close", listeners.onClose);
+      poke();
+    };
+    const onWire = watchWire;
+    torrent.on?.("wire", onWire);
+    torrent.on?.("verified", poke);
+    for (const wire of Array.isArray(torrent.wires) ? torrent.wires : []) watchWire(wire);
+    return () => {
+      torrent.removeListener?.("wire", onWire);
+      torrent.removeListener?.("verified", poke);
+      for (const wire of [...watched.keys()]) forget(wire);
+    };
+  }
+}

package/services/viewer/OutputForecastGeometry.js

@@ -0,0 +1,87 @@
+/**
+ * Cached piece geometry for playback forecasts. It is keyed by a live output
+ * object and explicitly forgotten when that output is disposed.
+ */
+export class OutputForecastGeometry {
+  #byOutput = new Map();
+  #host;
+
+  constructor(host) {
+    this.#host = host;
+  }
+
+  get(output) {
+    return this.#byOutput.get(output) ?? null;
+  }
+
+  forget(output) {
+    return this.#byOutput.delete(output);
+  }
+
+  size() {
+    return this.#byOutput.size;
+  }
+
+  segmentsOf(output, sessionInit, inventory, positionSeconds) {
+    const timeline = output.timeline;
+    const count = timeline?.segmentCount ?? 0;
+    let forecast = this.#byOutput.get(output);
+    if (!forecast) {
+      forecast = { pieces: [], geometry: {} };
+      this.#byOutput.set(output, forecast);
+    }
+    const kept = forecast.pieces;
+    const segments = [];
+    const lookahead = Number(this.#host.lookaheadSeconds);
+    const start = Number.isFinite(positionSeconds) ? Math.max(0, positionSeconds) : 0;
+    const end = Number.isFinite(lookahead) && lookahead > 0 ? start + lookahead : Number.POSITIVE_INFINITY;
+    let low = 0, high = count;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (timeline.publishedStartOf(middle + 1) <= start) low = middle + 1;
+      else high = middle;
+    }
+    const first = Math.max(0, low - 1);
+    low = first;
+    high = count;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (timeline.publishedStartOf(middle) < end) low = middle + 1;
+      else high = middle;
+    }
+    const last = low;
+    const indexes = new Set([0]);
+    for (let index = first; index < last; index++) indexes.add(index);
+    for (const index of indexes) {
+      const endSeconds = timeline.publishedStartOf(index + 1);
+      const ranges = inventory.has(index) ? this.#host.finishedMediaRangesOf(output, index) : undefined;
+      const mediaRanges = ranges && output.segmentFormat?.servedMediaRanges ?
+        output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined;
+      if (index !== 0 && mediaRanges === undefined && !inventory.has(index) &&
+        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) &&
+        !this.#host.endsWithinPlayerSeekTolerance(endSeconds, positionSeconds) &&
+        endSeconds < positionSeconds) {
+        continue;
+      }
+      const startSeconds = timeline.publishedStartOf(index);
+      const sourceInputs = this.#host.sourceInputsFor?.(output, index) ?? undefined;
+      const previous = kept[index];
+      if (previous && previous.startSeconds === startSeconds && previous.endSeconds === endSeconds &&
+        previous.mediaRanges === mediaRanges && sameInputs(previous.sourceInputs, sourceInputs)) {
+        segments.push(previous);
+        continue;
+      }
+      const segment = { index, startSeconds, endSeconds, sourceInputs, mediaRanges };
+      kept[index] = segment;
+      segments.push(segment);
+    }
+    if (kept.length > count) kept.length = count;
+    return segments;
+  }
+}
+
+function sameInputs(left, right) {
+  if (left === right) return true;
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+  return left.every((input, index) => input.sourceId === right[index].sourceId && input.ranges === right[index].ranges);
+}