@torrent-tv/proxy 2.97.20 → 2.97.21

package/package.json

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

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()
   };