@torrent-tv/proxy 2.98.4 → 2.98.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.98.4",
+  "version": "2.98.6",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/server.js

@@ -200,7 +200,7 @@ export async function startProxyServer({
     // The ONE forward reference here, and it is safe by construction: this fires
     // only once the worker thread is up and a piece has verified, which is long
     // after the declarations below have run.
-    onPiecesArrived: ({ sourceKey, fileIndexes }) => {
+    onPiecesArrived: ({ sourceKey, fileIndexes, arrived }) => {
       for (const fileIndex of fileIndexes) {
         mediaReads.bytesChanged(sourceKey, fileIndex);
         probeReads.bytesChanged(sourceKey, fileIndex);
@@ -211,7 +211,9 @@ export async function startProxyServer({
         // is read again now; nothing was recorded for that wait.
         keyframeTables.readAgainIfUnanswered({ sourceKey, fileIndex, logName: String(fileIndex) });
       }
-      outputParts.encodeInputs?.bytesChanged();
+      // Which bytes arrived, when the event names them: an input waiting for
+      // named bytes is tried again only when some of them have come.
+      outputParts.encodeInputs?.bytesChanged(Array.isArray(arrived) ? { sourceKey, ranges: arrived } : null);
     }
   });
   const selectedPort = await getPort({

package/services/encode/EncodeInputs.js

@@ -259,10 +259,27 @@ export class EncodeInputs {
     return this.take(output, from, to);
   }
 
-  bytesChanged() {
+  /**
+   * Bytes of a source changed: every waiting input is tried again, except one
+   * that waits for named bytes none of which have come. Tried at every piece
+   * of the file, a seek's input was prepared 28 times in 8.5 s on Home
+   * Assistant, each time asking the torrent thread which ranges it holds
+   * (171 ms on average), and the try that found its bytes could start only
+   * after the one in flight (r34, torrent-tv/meta#178).
+   *
+   * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> } | null} [arrived] -
+   *   The bytes that arrived, inclusive, when the event names them.
+   */
+  bytesChanged(arrived = null) {
     this.#revision++;
     for (const request of this.#requests.values()) {
-      if (!request.pending && request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
+      if (request.pending || request.result?.kind === "result" || request.result?.kind === "terminal") continue;
+      if (arrived && request.result?.kind === "needs-bytes" && !awaitedIn(request.result, arrived)) {
+        // Nothing it waits for has come: it stands as tried at this revision.
+        request.revision = this.#revision;
+        continue;
+      }
+      this.#prepare(request);
     }
   }
 
@@ -486,7 +503,9 @@ export class EncodeInputs {
       // found pieces missing, and the run was refused for good (torrent-tv/meta#178).
       if (this.#heldRanges !== null && !await this.#present(chosen.sources, held, request.timing)) {
         const [first] = chosen.sources;
-        return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges };
+        return { kind: "needs-bytes", sourceKey: first.sourceKey, fileIndex: first.fileIndex, ranges: first.input.ranges,
+          // Every source of the stretch, so the bytes of any of them wake it.
+          awaiting: chosen.sources.map(source => ({ sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges })) };
       }
       if (this.#requests.get(request.key) !== request) return undefined;
       this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
@@ -527,6 +546,21 @@ export class EncodeInputs {
   }
 }
 
+/**
+ * Whether some of the bytes an input waits for are among those that arrived.
+ *
+ * @param {{ sourceKey: string, fileIndex: number, ranges: Array<[number, number]>,
+ *   awaiting?: Array<{ sourceKey: string, fileIndex: number, ranges: Array<[number, number]> }> }} waiting
+ * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> }} arrived
+ * @returns {boolean}
+ */
+function awaitedIn(waiting, arrived) {
+  const sources = waiting.awaiting ?? [waiting];
+  return sources.some(source => source.sourceKey === arrived.sourceKey && Array.isArray(source.ranges) &&
+    arrived.ranges.some(range => range.fileIndex === source.fileIndex &&
+      source.ranges.some(([start, end]) => range.start <= end && range.end >= start)));
+}
+
 /**
  * Where a request has spent its time since it was asked, as one clause of its
  * log line. The resolutions include the reads of the file they made, and those

package/services/torrent/PlaybackProjection.js

@@ -341,6 +341,14 @@ export class PlaybackProjection {
   #ordered = true;
   /** The segments wanted whose ranges are not worked out yet. @type {Set<Segment>} */
   #unresolved = new Set();
+  /**
+   * Outputs whose next run's input is to be raised again before the windows
+   * are told: worked out once for everything a map or a pass changed, not at
+   * each segment that changed — on a cold start that was once for each of
+   * 4500 segments worked out (r34, torrent-tv/meta#178).
+   * @type {Set<OutputState>}
+   */
+  #raiseAgain = new Set();
   /** The time base of the last map, or 0 for a map stated in absolute time. */
   #base = 0;
   #absolute = true;
@@ -408,6 +416,7 @@ export class PlaybackProjection {
             segment.ready = now;
             this.#activate(segment);
             this.#track(segment);
+            this.#raiseAgain.add(output);
             reworked++;
           }
         }
@@ -423,8 +432,8 @@ export class PlaybackProjection {
         }
         if (leadMoved) for (const segment of output.segments) if (this.#reckon(segment)) reworked++;
       }
+      if (fresh || output.target !== (info.target ?? null)) this.#raiseAgain.add(output);
       output.target = info.target ?? null;
-      this.#raise(output);
     }
     for (const output of [...this.#outputs.values()]) if (!seen.has(output.outputKey)) this.#dropOutput(output);
     if (nextBase !== this.#base || absolute !== this.#absolute) this.#told = null;
@@ -463,7 +472,7 @@ export class PlaybackProjection {
     }
     this.#activate(segment);
     this.#track(segment);
-    this.#raise(segment.output);
+    this.#raiseAgain.add(segment.output);
   }
 
   /**
@@ -507,6 +516,8 @@ export class PlaybackProjection {
    *   deferred: boolean, deadlineAt?: number, standing: true }>}
    */
   windows() {
+    for (const output of this.#raiseAgain) if (this.#outputs.get(output.outputKey) === output) this.#raise(output);
+    this.#raiseAgain.clear();
     if (this.#told && this.#dirty.size === 0) return this.#told;
     for (const key of this.#dirty) this.#makeWindows(key);
     this.#dirty.clear();
@@ -560,6 +571,7 @@ export class PlaybackProjection {
     this.#lead(segment);
     this.#activate(segment);
     this.#track(segment);
+    this.#raiseAgain.add(segment.output);
     return true;
   }
 
@@ -753,6 +765,7 @@ export class PlaybackProjection {
       this.#unresolved.delete(segment);
     }
     this.#outputs.delete(output.outputKey);
+    this.#raiseAgain.delete(output);
     this.#told = null;
   }
 }

package/services/torrent/torrent-pool.js

@@ -1300,6 +1300,7 @@ export class TorrentPool {
     // depend on facts that are gone by the time it is said.
     if (Array.isArray(zones) && zones.length === 0) {
       withdrawPriorityMap(torrent, fileIndex);
+      reconcileAll();
       // The ends of the file go with it. They are kept for as long as the file
       // is open, and this is what says it is not.
       // And this may have been the last thing anybody wanted of this torrent.
@@ -1346,6 +1347,11 @@ export class TorrentPool {
     // Bands the map no longer has: a viewer moved on, and what they had wanted
     // is not wanted by anybody now.
     withdrawPriorityMap(torrent, fileIndex, ordered.length);
+    // THE SWARM IS TOLD WHEN THE MAP IS APPLIED, not at the next piece verified
+    // or the pool's timer: on Home Assistant a seek's map was applied and the
+    // swarm went on fetching the old first class for 1.16 s, until the next
+    // piece happened to be verified (r34, torrent-tv/meta#178).
+    reconcileAll();
     // WHAT THE SWARM WAS ACTUALLY TOLD, said on change and never on a timer.
     // The map was applied in silence: that it had been BUILT was visible in the
     // encoding's own line, and that the download had received it was visible

package/services/torrent/worker/client.js

@@ -254,7 +254,8 @@ export class TorrentWorkerClient {
           this.#onPiecesArrived({
             sourceKey: message.sourceKey,
               fileIndexes: Array.isArray(message.fileIndexes) ? message.fileIndexes : [],
-              ...(typeof message.reason === "string" ? { reason: message.reason } : {})
+              ...(typeof message.reason === "string" ? { reason: message.reason } : {}),
+              ...(Array.isArray(message.arrived) ? { arrived: message.arrived } : {})
           });
           break;
         default:

package/services/torrent/worker/worker.js

@@ -881,12 +881,36 @@ function describePieceBuffers() {
  * @param {object} torrent
  * @returns {void}
  */
-function announceArrivals(sourceKey, torrent, reason = "verified") {
+function announceArrivals(sourceKey, torrent, reason = "verified", piece = null) {
   const fileIndexes = [...demandFor(torrent).register.files()];
   if (fileIndexes.length === 0) {
     return;
   }
-  parentPort.postMessage({ type: Event.PIECES_CHANGED, sourceKey, fileIndexes, reason });
+  parentPort.postMessage({ type: Event.PIECES_CHANGED, sourceKey, fileIndexes, reason,
+    ...(Number.isSafeInteger(piece) ? { arrived: bytesOfPiece(torrent, piece) } : {}) });
+}
+
+/**
+ * The bytes of one piece, as each file it covers counts them: what a reader
+ * waiting for named bytes compares against, so a piece of another part of the
+ * file wakes nobody (torrent-tv/meta#178).
+ *
+ * @param {object} torrent
+ * @param {number} piece
+ * @returns {Array<{ fileIndex: number, start: number, end: number }>} Inclusive.
+ */
+function bytesOfPiece(torrent, piece) {
+  const pieceLength = Number(torrent.pieceLength);
+  const length = Number(torrent.length);
+  if (!(pieceLength > 0) || !(length > 0)) return [];
+  const start = piece * pieceLength;
+  const end = Math.min(length, start + pieceLength) - 1;
+  const arrived = [];
+  (torrent.files ?? []).forEach((file, fileIndex) => {
+    const from = Math.max(start, file.offset), to = Math.min(end, file.offset + file.length - 1);
+    if (to >= from) arrived.push({ fileIndex, start: from - file.offset, end: to - file.offset });
+  });
+  return arrived;
 }
 
 
@@ -917,7 +941,7 @@ function ensureArrivalsWired(sourceKey, torrent) {
   }
   arrivalsWired.add(torrent);
   holdingsChanged();
-  torrent.on("verified", () => announceArrivals(sourceKey, torrent));
+  torrent.on("verified", (piece) => announceArrivals(sourceKey, torrent, "verified", piece));
   torrent.on("piece-withdrawn", () => announceArrivals(sourceKey, torrent, "withdrawn"));
   torrent.once("close", () => {
     if (resolvedTorrents.get(sourceKey) !== torrent) return;