@torrent-tv/proxy 2.97.23 → 2.97.24

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -291,7 +291,7 @@ export class EncodeRuns {
   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);
+      if (run.isAlive && run.originalInput?.readThroughCache) bytes += Math.max(0, Number(run.originalInput.bytes) || 0);
     }
     return bytes;
   }
@@ -1024,6 +1024,9 @@ export class EncodeRuns {
     this.#lastInputToken += 1;
     const inputToken = this.#lastInputToken;
     if (admittedInput) admittedInput.runTag = `${startIndex}r${inputToken}`;
+    // Whether this run's FFmpeg keeps what it reads in its cache's file, which
+    // is what the budget counts on that file's disk.
+    if (admittedInput?.original) admittedInput.readThroughCache = this.#host.readsThroughCache?.() === true;
     const buildCommand = admittedInput.original ? buildOriginalCommand : buildAdmittedCommand;
     const built = buildCommand({
       admittedInput,
@@ -1044,7 +1047,8 @@ export class EncodeRuns {
       endIndex: admittedInput.original ? inputEnd
         : Number.isInteger(ordered?.to) ? ordered.to : runEnd >= startIndex ? runEnd : session.timeline.segmentCount - 1,
       videoEncoder: this.#host.videoEncoder,
-      segmentDurationSec: this.#host.segmentDurationSec
+      segmentDurationSec: this.#host.segmentDurationSec,
+      readThroughCache: admittedInput.readThroughCache === true
     });
     const { args, cutTimes } = built;
     // The piece before the start, made only to have its group in hand, is

package/services/encode/input-cache.js

@@ -0,0 +1,63 @@
+/**
+ * @file Whether this machine's FFmpeg can read an encoder's input through its
+ * `cache:` protocol, and on which directory's disk that cache lies.
+ *
+ * FFmpeg's cache (libavformat/cache.c) keeps what it has read in a temporary
+ * file opened by `avpriv_tempfile`, and a Linux build can only open that file
+ * in /tmp (libavutil/file_open.c n8.1, `mkstemp`); a Windows or Android build
+ * opens it where FFmpeg runs. Where no /tmp can be written, every run reading
+ * through the cache fails at its open — checked on Home Assistant with a
+ * read-only root: "ff_tempfile: Cannot open temporary file
+ * /tmp/ffcacheXXXXXX", while the same file read directly opened. So one small
+ * read through the cache is tried at startup with this proxy's own FFmpeg, and
+ * until it has succeeded an input is read directly (torrent-tv/meta#178).
+ */
+
+import { spawn as nodeSpawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Where FFmpeg keeps its cache's file: /tmp on a build that uses `mkstemp`,
+ * else where FFmpeg runs, which for a run is a directory of the segments.
+ *
+ * @param {string} [platform]
+ * @returns {string | null} null for the segments' own directory.
+ */
+export function inputCacheRoot(platform = process.platform) {
+  return platform === "win32" || platform === "android" ? null : "/tmp";
+}
+
+/**
+ * Read a small file through FFmpeg's cache once.
+ *
+ * @param {object} params
+ * @param {string} params.ffmpegBin
+ * @param {typeof nodeSpawn} [params.spawn]
+ * @param {string} [params.scratch] - Where the file read is written.
+ * @returns {Promise<{ available: boolean, reason: string }>}
+ */
+export async function probeInputCache({ ffmpegBin, spawn = nodeSpawn, scratch = os.tmpdir() }) {
+  let directory = null;
+  try {
+    directory = await mkdtemp(path.join(scratch, "ttv-input-cache-"));
+    const file = path.join(directory, "input.bin");
+    await writeFile(file, randomBytes(64 * 1024));
+    const { code, error } = await new Promise((resolve) => {
+      let stderr = "";
+      const child = spawn(ffmpegBin, ["-v", "error", "-nostdin", "-f", "data", "-i", `cache:file:${file}`,
+        "-map", "0", "-c", "copy", "-f", "null", "-"], { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+      child.stderr?.on("data", (chunk) => { stderr += chunk; });
+      child.once("error", (failure) => resolve({ code: null, error: failure.message }));
+      child.once("close", (exitCode) => resolve({ code: exitCode, error: stderr.trim().split(/\r?\n/).pop() ?? "" }));
+    });
+    return code === 0 ? { available: true, reason: "a read through it completed" }
+      : { available: false, reason: `FFmpeg ${code === null ? "did not start" : `exited ${code}`}: ${error || "no message"}` };
+  } catch (error) {
+    return { available: false, reason: `the file to read could not be prepared: ${error instanceof Error ? error.message : String(error)}` };
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+  }
+}

package/services/encode/source-command.js

@@ -278,7 +278,10 @@ export function buildOriginalCommand(params) {
   // 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}`;
+  // Only where a read through it has worked on this machine
+  // (`encode/input-cache.js`); elsewhere the input is read directly.
+  const readThroughCache = params.readThroughCache !== false;
+  const url = source => `${readThroughCache ? "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,7 +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 { inputCacheRoot, probeInputCache } from "../encode/input-cache.js";
 import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
@@ -341,6 +341,7 @@ export function wireOutputs({
     get outputs() { return parts.outputs; },
     get priority() { return parts.priority; },
     get segmentDurationSec() { return parts.segmentDurationSec; },
+    readsThroughCache: () => parts.inputCacheAvailable === true,
     segmentFiles,
     get videoEncoder() { return parts.encoders.current; },
     get encoders() { return parts.encoders; },
@@ -627,6 +628,16 @@ export function wireOutputs({
   parts.coldStarts = new ColdStarts();
   parts.enabled = Boolean(enabled);
   parts.ffmpegBin = ffmpegBin;
+  // Whether a run may read its input through FFmpeg's cache: once a read
+  // through it has worked with this FFmpeg, and directly until then
+  // (`encode/input-cache.js`).
+  parts.inputCacheAvailable = false;
+  if (parts.enabled && ffmpegBin) {
+    void probeInputCache({ ffmpegBin }).then(({ available, reason }) => {
+      parts.inputCacheAvailable = available;
+      logger.info(`encoder input: ${available ? "read through FFmpeg's cache" : "read directly"} — ${reason}`);
+    });
+  }
   parts.sourceInputsFor = typeof sourceInputsFor === "function" ? sourceInputsFor : null;
   parts.keyframeTables = keyframeTables;
   // Where measurements about this host are kept between runs. Empty means
@@ -1045,9 +1056,9 @@ 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 },
+    // FFmpeg's cache keeps its file in /tmp, or where FFmpeg runs on a build
+    // without `mkstemp` — an output directory of the segments.
+    inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: inputCacheRoot() },
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger