@torrent-tv/proxy 2.97.19 → 2.97.21

package/package.json

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

package/server.js

@@ -79,6 +79,7 @@ import { readHostFingerprint } from "./services/encode/fingerprint.js";
 import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
 import { benchmarkAudio } from "./services/encode/audio-calibration.js";
 import { logger } from "./utils/logger.js";
+import { takeTurns } from "./utils/take-turns.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
 import { startupCpuProfile } from "./services/storage/cpu-profile.js";
 import { startProcessorReport } from "./services/storage/processor-report.js";
@@ -532,6 +533,7 @@ export async function startProxyServer({
       // answers; asking every segment held the main thread for 3.3 s on a cold
       // two-hour AVI (torrent-tv/meta#178).
       const waiting = new Set();
+      const turn = takeTurns();
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
         // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
@@ -571,14 +573,14 @@ export async function startProxyServer({
               value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
             }
           } catch { value = null; }
-          // A zone worked out gives the thread back before the next: worked out
-          // in one stretch, the first pass over a film's 4000 zones held the main
-          // thread 5-7 s while FFmpeg's first open waited for its answers. What
-          // was worked out is kept, so a pass a newer map ends is not lost
+          // The pass shares the thread in equal turns (`takeTurns`): in one
+          // stretch the first pass over a film's 4000 zones held the main thread
+          // for all of its work, and handed back after every zone it took
+          // 14.7-22 s while the start forecast waited for it. What was worked
+          // out is kept, so a pass a newer map ends is not lost
           // (torrent-tv/meta#178).
           if (value?.kind === "result") segmentSourceRanges.set(rangesKey, value.ranges);
-          await new Promise(resolve => setImmediate(resolve));
-          if (!map.isCurrent()) return [];
+          if (await turn() && !map.isCurrent()) return [];
           if (value?.kind === "result") {
             convert(value.ranges);
             continue;

package/services/encode/EncodeRuns.js

@@ -281,6 +281,21 @@ export class EncodeRuns {
     return this.#runsByInputToken.get(runToken)?.originalInput ?? null;
   }
 
+  /**
+   * What FFmpeg's caches may hold for the live runs that read an original
+   * file: at most what each was admitted, since a cache keeps what its run
+   * read of it (`source-command.js`).
+   *
+   * @returns {number}
+   */
+  inputCacheBytes() {
+    let bytes = 0;
+    for (const run of this.#runsByInputToken.values()) {
+      if (run.isAlive && run.originalInput) bytes += Math.max(0, Number(run.originalInput.bytes) || 0);
+    }
+    return bytes;
+  }
+
   /**
    * @param {object} output
    * @returns {number}

package/services/encode/source-command.js

@@ -270,7 +270,15 @@ export function buildOriginalCommand(params) {
   const primary = sourceFor(audioOnly ? "audio" : "video");
   const audio = sourceFor("audio") ?? primary;
   if (!primary) throw new Error("The selected source track is absent from original input.");
-  const url = source => new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href;
+  // READ THROUGH FFMPEG'S CACHE, so a return to bytes already read is not a
+  // new request. An OpenDML AVI's open seeks from its super index in the header
+  // to each standard index and back: on the field's two-hour AVI, 195 indexes
+  // made 390 requests and 636-1243 MB of answers, and the first piece came 4.8 s
+  // after the start against 2.8 s through the cache, which made 3 requests;
+  // the pieces were the same to the byte, on FFmpeg 6.1 and 8.1.2 (Home
+  // Assistant 2026-10-13, torrent-tv/meta#178). The cache's file holds what
+  // FFmpeg read and is counted by the budget (`EncodeRuns.inputCacheBytes`).
+  const url = source => `cache:${new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href}`;
   // The container named the bytes FFmpeg's stream search reads for this much
   // media time; the search is told the same, whatever its own default.
   const openArgs = source => Number.isFinite(source.input.streamSearchSeconds)

package/services/server/wire-outputs.js

@@ -93,6 +93,7 @@ import { audioReadingFor } from "../encode/audio-work-rate.js";
 import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
@@ -345,7 +346,7 @@ export function wireOutputs({
     get encoders() { return parts.encoders; },
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
     productionFailed: (output) => parts.renditions.noteProductionFailed(output),
-    encodersChanged: () => { parts.applyDownloadShare?.(); onEncodersChanged?.(); },
+    encodersChanged: () => { parts.applyDownloadShare?.(); reviseInputCaches(); onEncodersChanged?.(); },
   });
   // How much film is ready in front of the viewers, said; and the spare soundtracks fetched once it is full.
   parts.cushion = new CushionReport({
@@ -1044,10 +1045,25 @@ export function wireOutputs({
     memory: parts.memoryClaimant,
     encodeInputs: parts.encodeInputs,
     indexMemory,
+    // FFmpeg puts its temporary files in /tmp, or where it runs when there is
+    // none — an output directory of the segments.
+    inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: existsSync("/tmp") ? "/tmp" : null },
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger
   });
+  /**
+   * A run reading an original file started or ended, so the disk its cache is
+   * on is divided again — only when what the caches may hold has changed.
+   */
+  let inputCachesDivided = 0;
+  function reviseInputCaches() {
+    const bytes = parts.encodeRuns?.inputCacheBytes() ?? 0;
+    const on = parts.machineBudget?.inputCachesOn;
+    if (!on || bytes === inputCachesDivided) return;
+    inputCachesDivided = bytes;
+    void parts.machineBudget.revise(on, "encoder input caches").catch(error => logger.warn(`input cache budget: ${error.message}`));
+  }
   /**
    * What starting a run costs this output before its first piece is encoded:
    * its own measured open where it has one (`RunCosts.openOf`), else the

package/services/storage/wire.js

@@ -44,6 +44,9 @@ import { availableMemoryBytes } from "./machine-memory.js";
  *   not fit in memory is spilled, so this share decides how much disk is needed.
  * @param {{ held: () => number, allow: (bytes: number) => unknown, root?: string }} [params.wholeFiles] -
  *   Files downloaded whole and kept as files, on the torrent thread as well.
+ * @param {{ held: () => number, root?: string | null }} [params.inputCaches] -
+ *   What FFmpeg's caches of original input hold, and the directory FFmpeg puts
+ *   them in (the segments' disk when none).
  * @param {import("./Diagnostics.js").Diagnostics} [params.diagnostics] - The
  *   evidence. Built where the collectors are, so one object is both registered
  *   here and consulted by them.
@@ -64,6 +67,7 @@ export function wireMachineBudget({
   encodeInputs,
   indexMemory,
   wholeFiles,
+  inputCaches,
   diagnostics,
   diagnosticsRoot = "",
   readFree,
@@ -153,6 +157,25 @@ export function wireMachineBudget({
     });
   }
 
+  // FFMPEG'S CACHE OF WHAT A RUN READ from an original file (`cache:`,
+  // `encode/source-command.js`): a temporary file where FFmpeg puts its own,
+  // as large as what the run has read and at most what it was admitted. Held
+  // while the run lives and given back by nobody else, so it is required in
+  // full and the rest of its disk is divided after it.
+  let inputCachesOn = null;
+  if (typeof inputCaches?.held === "function") {
+    inputCachesOn = inputCaches.root ? deviceOf(inputCaches.root) : segmentsOn;
+    defineDisk(inputCachesOn, inputCaches.root || segmentStore.root);
+    budget.register({
+      name: "encoder input caches",
+      resource: inputCachesOn,
+      held: () => inputCaches.held(),
+      wanted: () => inputCaches.held(),
+      required: () => inputCaches.held(),
+      allow: () => {}
+    });
+  }
+
   let evidenceOn = null;
   if (diagnostics) {
     evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
@@ -188,6 +211,8 @@ export function wireMachineBudget({
       return budget.revise(resource, because);
     },
     segmentBytes: () => segmentBytes,
+    /** The disk FFmpeg's input caches are counted on, or null when none are. */
+    inputCachesOn,
     diagnostics: diagnostics ?? null,
     describe: () => budget.describe()
   };

package/utils/take-turns.js

@@ -0,0 +1,28 @@
+/**
+ * Long work on one thread, shared with the rest of that thread in equal turns.
+ *
+ * The returned function is called between steps of the work. It hands the
+ * thread back once the work has run, since it last did, as long as the rest
+ * of the thread took in its own turn then: the work takes at most about twice
+ * its own time, and nothing else waits longer than it took itself. Handed back
+ * after every step, the download map's first pass over a two-hour AVI took
+ * 14.7-22 s of wall time for about 4 s of its own work, and the start forecast,
+ * which needs the whole pass, could not answer meanwhile; held in one stretch
+ * it held the thread for that work (Home Assistant 2026-10-12,
+ * torrent-tv/meta#178).
+ *
+ * @param {{ now?: () => number, nextTurn?: () => Promise<void> }} [options]
+ * @returns {() => Promise<boolean>} Resolves true when the thread was handed back.
+ */
+export function takeTurns({ now = () => performance.now(), nextTurn = () => new Promise(resolve => setImmediate(resolve)) } = {}) {
+  let workingSince = now();
+  let othersTook = 0;
+  return async () => {
+    if (now() - workingSince < othersTook) return false;
+    const handedBackAt = now();
+    await nextTurn();
+    workingSince = now();
+    othersTook = workingSince - handedBackAt;
+    return true;
+  };
+}