@torrent-tv/proxy 2.95.3 → 2.95.4

package/services/viewer/playback-readiness.js

@@ -208,6 +208,8 @@ export function predictPlaybackReadiness(input = {}) {
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
     const { track, segments } = state;
+    const processingCoverage = numericCoverage((Array.isArray(track.processingRanges) ? track.processingRanges : [])
+      .filter(range => Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start));
     const measuredBitsPerMediaSecond = state.bitsPerMediaSecond;
     for (const segment of segments) {
       // Media the page already holds is not transferred again.
@@ -230,9 +232,7 @@ export function predictPlaybackReadiness(input = {}) {
       // Attribute unfinished work to the actual run interval. A global
       // position from another run must not erase a missing earlier segment.
       const workStart = segment.startSeconds;
-      const remainingProcessing = uncoveredIntervals({ start: workStart, end: segment.endSeconds },
-        (Array.isArray(track.processingRanges) ? track.processingRanges : []).filter((range) =>
-          Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start));
+      const remainingProcessing = uncoveredIntervals({ start: workStart, end: segment.endSeconds }, processingCoverage);
       const encodeWork = produced ? 0 : remainingProcessing.reduce((sum, part) => sum + part.end - part.start, 0);
 
       const sourceByteIntervals = new Map();
@@ -309,29 +309,29 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
   const trackFinish = trackState.map(({ track }) => finiteNonNegative(track.startupRemainingSeconds));
+  const sourceByteCoverage = new Map([...sourceByteService].map(([id, ranges]) => [id, numericCoverage(ranges)]));
+  const sourceArrivals = new Map([...sourceByteService].map(([id, ranges]) => [id, indexedArrivals(ranges)]));
   let transferFinish = 0;
   const completions = [];
   const productions = [];
   for (const job of jobs) {
     const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
-    const sourceArrivals = [];
+    let sourceArrivalAt = 0;
     for (const [sourceId, ranges] of sourceByteIntervals) {
-      const served = sourceByteService.get(sourceId) ?? [];
       for (const interval of ranges) {
-        if (uncoveredIntervals(interval, served).length) return result(false, null, buffered, reserve, null, "download-schedule-unavailable", preparedSegments);
-        for (const part of served.filter(part => part.end > interval.start && part.start < interval.end)) {
-          sourceArrivals.push({ at: part.finish });
-        }
+        const missing = uncoveredIntervals(interval, sourceByteCoverage.get(sourceId) ?? []);
+        if (missing.length) return { ...result(false, null, buffered, reserve, null, "download-schedule-unavailable", preparedSegments),
+          unavailableSource: { sourceId, segmentIndex: segment.index, range: interval, missing } };
+        sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId)));
       }
-      sourceByteService.set(sourceId, served);
     }
     // Production accepts a complete held segment input. It cannot overlap its
     // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    const admittedAt = Math.max(trackFinish[trackIndex], ...sourceArrivals.map(({ at }) => at));
+    const admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
     const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
-    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivals.some(({ at }) => at > 0) });
+    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0 });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));
     transferFinish = deliveryAt;
     completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment });
@@ -483,15 +483,57 @@ function heldRanges(ranges, segments, unit) {
   return held;
 }
 
+/** Coverage is joined once per resource, independently of arrival times. */
+function numericCoverage(ranges) {
+  const joined = [];
+  for (const range of [...ranges].sort((left, right) => left.start - right.start || left.end - right.end)) {
+    const previous = joined.at(-1);
+    if (previous && range.start <= previous.end) previous.end = Math.max(previous.end, range.end);
+    else joined.push({ start: range.start, end: range.end });
+  }
+  return joined;
+}
+
+/** Already held bytes have no arrival delay. Index future arrivals once. */
+function indexedArrivals(ranges) {
+  let maximumEnd = 0;
+  return ranges.filter(range => range.finish > 0)
+    .sort((left, right) => left.start - right.start || left.end - right.end)
+    .map(range => ({ ...range, maximumEnd: maximumEnd = Math.max(maximumEnd, range.end) }));
+}
+
+function latestArrival(interval, ranges = []) {
+  let low = 0, high = ranges.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if (ranges[middle].maximumEnd <= interval.start) low = middle + 1;
+    else high = middle;
+  }
+  let finish = 0;
+  for (let index = low; index < ranges.length && ranges[index].start < interval.end; index++) {
+    if (ranges[index].end > interval.start) finish = Math.max(finish, ranges[index].finish);
+  }
+  return finish;
+}
+
+/** Exact gaps in sorted disjoint numeric coverage, without per-range splitting. */
 function uncoveredIntervals(interval, served) {
-  let remaining = [{ ...interval }];
-  for (const held of served) {
-    remaining = remaining.flatMap((part) => held.end <= part.start || held.start >= part.end ? [part] : [
-      { start: part.start, end: Math.min(part.end, held.start) },
-      { start: Math.max(part.start, held.end), end: part.end }
-    ].filter(({ start, end }) => end > start));
+  let low = 0, high = served.length;
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    if (served[middle].end <= interval.start) low = middle + 1;
+    else high = middle;
+  }
+  const missing = [];
+  let cursor = interval.start;
+  for (let index = low; index < served.length && cursor < interval.end; index++) {
+    const held = served[index];
+    if (held.start >= interval.end) break;
+    if (held.start > cursor) missing.push({ start: cursor, end: held.start });
+    cursor = Math.max(cursor, held.end);
   }
-  return remaining;
+  if (cursor < interval.end) missing.push({ start: cursor, end: interval.end });
+  return missing;
 }
 
 /**

package/services/viewer/segment-demands.js

@@ -16,13 +16,17 @@ export function segmentDemands(output, fileIndex, zones) {
     if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from)) throw new Error("An output segment needs a valid interval.");
     const overlapping = zones.filter(zone => zone.priority > 0 && zone.from < to && zone.to > from);
     if (!overlapping.length) continue;
-    const owner = overlapping.reduce((first, zone) => (zone.deadlineAt ?? Infinity) < (first.deadlineAt ?? Infinity) ? zone : first);
+    // A zone states the deadline of its near edge. A later segment within it
+    // is reached later, at one second of film per second of playback.
+    const deadlineOf = zone => Number.isFinite(zone.deadlineAt)
+      ? zone.deadlineAt + Math.max(0, from - zone.from) * 1000 : Infinity;
+    const owner = overlapping.reduce((first, zone) => deadlineOf(zone) < deadlineOf(first) ? zone : first);
     demands.push({ index, from, to, tracks, owner,
       priority: Math.max(...overlapping.map(zone => zone.priority)),
       urgent: overlapping.some(zone => zone.urgent),
       behind: overlapping.every(zone => zone.behind),
       deferred: overlapping.every(zone => zone.deferred),
-      deadlineAt: Math.min(...overlapping.map(zone => Number.isFinite(zone.deadlineAt) ? zone.deadlineAt : Infinity)) });
+      deadlineAt: Math.min(...overlapping.map(deadlineOf)) });
   }
   return demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
 }

package/services/torrent/download/DeadlineScheduler.js

@@ -1,195 +0,0 @@
-import { piecesOf } from "../demand/pieces.js";
-import { pieceStoreOf } from "../piece-store-of.js";
-
-/** The block length and one-second request allowance used by WebTorrent. */
-const BLOCK_BYTES = 16 * 1024;
-const compiledDemand = new WeakMap();
-const requestArrivals = new WeakMap();
-
-/** Keep the same reassignment evidence in an isolated forecast request. */
-export function copyRequestArrival(source, target) {
-  if (requestArrivals.has(source)) requestArrivals.set(target, requestArrivals.get(source));
-  return target;
-}
-
-function requestArrival(wire, request, now) {
-  if (!requestArrivals.has(request)) {
-    const speed = Number(wire.downloadSpeed?.());
-    let bytes = 0;
-    for (const queued of wire.requests ?? []) {
-      bytes += queued.length;
-      if (queued === request) break;
-    }
-    requestArrivals.set(request, speed > 0 ? now + bytes / speed * 1000 : Infinity);
-  }
-  return requestArrivals.get(request);
-}
-
-export function peerRequestCapacity(torrent, wire, speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0)) {
-  if (wire.type === "webSeed") {
-    return Math.min(1 + Math.ceil(speed / torrent.pieceLength), torrent.maxWebConns);
-  }
-  let capacity = 2 + Math.ceil(speed / BLOCK_BYTES);
-  const maximum = wire.peerExtendedHandshake?.reqq;
-  if (Number.isFinite(maximum) && maximum > 0) capacity = Math.min(capacity, Math.floor(maximum));
-  return capacity;
-}
-
-export function requestCompletionAt(wire, bytes, now, speed = Number(wire.downloadSpeed?.())) {
-  if (!(speed > 0)) return Number.POSITIVE_INFINITY;
-  const queued = (wire.requests ?? []).reduce((total, request) => total + request.length, 0);
-  return now + (queued + bytes) / speed * 1000;
-}
-
-export function peerCanServe(wire, piece) {
-  return !wire.destroyed && (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.includes(piece))) &&
-    wire.peerPieces?.get(piece);
-}
-
-function peerCanRequest(wire) {
-  return !wire.destroyed &&
-    (!wire.peerChoking || (wire.hasFast && wire.peerAllowedFastSet?.length > 0));
-}
-
-/** Identical map ordering for present requests and conditional future requests. */
-export function compareDownloadCandidates(a, b) {
-  return a.deadlineAt - b.deadlineAt || b.priority - a.priority || a.order - b.order || a.piece - b.piece;
-}
-
-/** One ordering across torrents; peers retain protocol-owned block verification. */
-export class DeadlineScheduler {
-  #entries;
-  #running = false;
-  #store;
-
-  constructor({ entries, findStore = pieceStoreOf }) {
-    this.#entries = entries;
-    this.#store = findStore;
-  }
-
-  reconcile(now = Date.now(), { torrent = null, wire = null } = {}) {
-    if (this.#running) return { requested: 0, reassigned: 0 };
-    // WebTorrent updates each peer in turn. A full or choked peer cannot issue
-    // a request, so its heartbeat must not scan every file's byte availability.
-    if (wire && (!peerCanRequest(wire) ||
-      (wire.requests?.length ?? 0) >= peerRequestCapacity(torrent, wire))) {
-      return { requested: 0, reassigned: 0 };
-    }
-    this.#running = true;
-    try {
-      const entries = [...this.#entries()].filter(entry => !torrent || entry.torrent === torrent);
-      return dispatchDownloadCandidates(downloadCandidates(entries, this.#store), now, { wire });
-    } finally {
-      this.#running = false;
-    }
-  }
-}
-
-
-/** The published map defines the same candidates for every scheduling pass. */
-export function downloadCandidates(entries, findStore = pieceStoreOf) {
-  const candidates = [];
-  for (const { torrent, register } of entries) {
-    if (torrent.destroyed || torrent.ready === false || typeof torrent._request !== "function") continue;
-    const store = findStore(torrent);
-    let compiled = compiledDemand.get(register);
-    if (!Number.isSafeInteger(register.revision) || compiled?.revision !== register.revision ||
-        compiled.torrent !== torrent || compiled.files !== torrent.files || compiled.pieceLength !== torrent.pieceLength) {
-      const byPiece = new Map();
-      for (const window of register.windows()) {
-        const file = torrent.files?.[window.fileIndex];
-        if (!file) continue;
-        const range = piecesOf({ fileOffset: file.offset, byteStart: window.byteStart, byteEnd: Math.min(window.byteEnd, file.length - 1), pieceLength: torrent.pieceLength });
-        if (!range) continue;
-        for (let piece = range.from; piece <= range.to; piece++) {
-          const prior = byPiece.get(piece);
-          if (!prior || window.deadlineAt < prior.deadlineAt ||
-            (window.deadlineAt === prior.deadlineAt && (window.priority > prior.priority ||
-              (window.priority === prior.priority && window.order < prior.order)))) {
-            byPiece.set(piece, { torrent, piece, deadlineAt: window.deadlineAt, priority: window.priority, order: window.order, requestId: window.requestId });
-          }
-        }
-      }
-      compiled = { torrent, revision: register.revision, files: torrent.files,
-        pieceLength: torrent.pieceLength, pieces: [...byPiece.values()] };
-      compiledDemand.set(register, compiled);
-    }
-    for (const candidate of compiled.pieces) {
-      const present = store?.locationOf ? store.locationOf(candidate.piece) !== "missing" : torrent.bitfield?.get(candidate.piece);
-      if (!present) candidates.push(candidate);
-    }
-  }
-  candidates.sort(compareDownloadCandidates);
-  return candidates;
-}
-
-/** Run against protocol peers or an isolated future-state copy. */
-export function dispatchDownloadCandidates(candidates, now, { wire: changedWire = null } = {}) {
-  let requested = 0, reassigned = 0;
-  // Rates and advertised limits cannot change during this synchronous pass.
-  // Read each peer once, and only inspect torrents once regardless of map size.
-  const readings = new Map();
-  const readingOf = (torrent, wire) => {
-    let reading = readings.get(wire);
-    if (!reading) {
-      const speed = Math.max(0, Number(wire.downloadSpeed?.()) || 0);
-      readings.set(wire, reading = { speed, capacity: peerRequestCapacity(torrent, wire, speed) });
-    }
-    return reading;
-  };
-  const available = (torrent, wire) => peerCanRequest(wire) &&
-    (wire.requests?.length ?? 0) < readingOf(torrent, wire).capacity;
-  const completionAt = (torrent, wire, bytes) =>
-    requestCompletionAt(wire, bytes, now, readingOf(torrent, wire).speed);
-  const writable = new Map();
-  for (const torrent of new Set(candidates.map(candidate => candidate.torrent))) {
-    const peers = (changedWire ? [changedWire] : torrent.wires ?? [])
-      .filter(wire => available(torrent, wire));
-    if (peers.length) writable.set(torrent, peers);
-  }
-  for (const candidate of candidates) {
-    if (!writable.size) break;
-    const { torrent, piece, deadlineAt, requestId } = candidate;
-    if (!writable.has(torrent)) continue;
-    const peers = writable.get(torrent);
-    const wires = peers.filter(wire => peerCanServe(wire, piece) && available(torrent, wire));
-    while (wires.length) {
-      wires.sort((a, b) => completionAt(torrent, a, BLOCK_BYTES) - completionAt(torrent, b, BLOCK_BYTES) ||
-        (a.requests?.length ?? 0) - (b.requests?.length ?? 0));
-      const wire = wires[0];
-      const before = wire.requests?.length ?? 0;
-      let accepted = torrent._request(wire, piece, false);
-      if (!accepted && Number.isFinite(deadlineAt)) {
-        const fasterAt = completionAt(torrent, wire, BLOCK_BYTES);
-        for (const slower of torrent.wires ?? []) {
-          if (slower === wire || typeof slower.cancel !== "function") continue;
-          const lateAt = completionAt(torrent, slower, 0);
-          if (!Number.isFinite(lateAt) || !(lateAt > deadlineAt && fasterAt < lateAt)) continue;
-          const request = slower.requests?.find(one => one.piece === piece);
-          if (!request) continue;
-          // A later queue estimate must not move the same block between peers
-          // indefinitely. Reassignment must improve its previous arrival;
-          // protocol completion or timeout ends this request's evidence.
-          if (!(fasterAt < requestArrival(slower, request, now))) continue;
-          slower.cancel(piece, request.offset, request.length);
-          reassigned++;
-          torrent.emit?.("download-request-cancelled", { ...request, reason: "deadline-reassigned", requestId });
-          accepted = torrent._request(wire, piece, false);
-          if (accepted) {
-            const replacement = wire.requests?.find(one => one.piece === piece && one.offset === request.offset);
-            if (replacement) requestArrivals.set(replacement, fasterAt);
-          }
-          if (accepted) break;
-        }
-      }
-      if (accepted) {
-        requested++;
-        torrent.emit?.("download-requested", { piece, deadlineAt, requestId, peer: wire.remoteAddress, queued: wire.requests?.length ?? 0 });
-      }
-      if (!accepted || (wire.requests?.length ?? 0) <= before ||
-        (wire.requests?.length ?? 0) >= readingOf(torrent, wire).capacity) wires.shift();
-    }
-    if (!peers.some(wire => available(torrent, wire))) writable.delete(torrent);
-  }
-  return { requested, reassigned };
-}