@torrent-tv/proxy 2.97.22 → 2.97.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.97.22",
+  "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/EncodeRun.js

@@ -123,6 +123,8 @@ export class EncodeRun {
    */
   #pendingAtStop = null;
   #closedTimings = new Map();
+  /** When the encoder named each closed piece on its channel, until it is published. */
+  #namedAt = new Map();
   #publicationError = null;
   #publicationCode = null;
   #inputTruncated = false;
@@ -622,6 +624,7 @@ export class EncodeRun {
       if (name.length === 0) {
         continue;
       }
+      this.#namedAt.set(name, this.now());
       if (this.#publicationError) continue;
       if (this.#stopping) {
         // Flushed by our stop. Never published; it tells where the piece closed
@@ -681,7 +684,8 @@ export class EncodeRun {
       // name a request can actually ask for.
       let served;
       try {
-        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null, { tentative });
+        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null,
+          { tentative, namedAt: this.#namedAt.get(name) ?? null });
       } catch (error) {
         if (quiet) {
           // A piece closed before our stop that cannot be proved whole is not
@@ -702,7 +706,10 @@ export class EncodeRun {
       } finally {
         // A piece not proved whole on its own keeps its timing for the file
         // after it.
-        if (!tentative || served) this.#closedTimings.delete(name);
+        if (!tentative || served) {
+          this.#closedTimings.delete(name);
+          this.#namedAt.delete(name);
+        }
       }
 
       if (!served) return false;

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
@@ -1121,7 +1125,7 @@ export class EncodeRuns {
       // from it — a re-encoded picture, or sound served as its own output. Such
       // a piece is published on its own line (torrent-tv/meta#178).
       publishesAlone: this.publishesAlone(session),
-      onClosed: (name, following, timing, { tentative = false } = {}) => {
+      onClosed: (name, following, timing, { tentative = false, namedAt = null } = {}) => {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
@@ -1131,6 +1135,8 @@ export class EncodeRuns {
         if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         const address = session.outputKey ?? "";
+        // Read before anything rewrites it: when the encoder finished it.
+        const writtenAt = this.#host.segmentFiles.writtenAtOf?.(address, name) ?? null;
         const fmp4 = admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only";
         // The first piece of a run that read the picture from its keyframe:
         // its leading pictures are the ones the run before made, or none.
@@ -1157,6 +1163,14 @@ export class EncodeRuns {
         const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         this.#leadingByOutput.get(address)?.delete(index);
+        // WHERE A LATE PIECE'S TIME WENT: the encoder writing it, this process
+        // getting to its name, or its publication waiting for the file after
+        // it. A piece 5.7 s apart from the one before stopped a viewer inside a
+        // running run, and nothing said which (torrent-tv/meta#178).
+        const since = at => (Number.isFinite(at) ? `+${Math.round(at - run.startedAt)}ms` : "unknown");
+        this.#host.logger.info(`encode-run #${run.from}..#${run.to} on ${address}: #${index} written by the encoder ${since(writtenAt)}, ` +
+          `named ${since(namedAt)}, published ${since(run.now())} ` +
+          (following ? `when ${following} closed` : tentative ? "on its own" : "at the run's end"));
         return published;
 
       },

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

package/services/storage/segment-store/SegmentStore.js

@@ -594,6 +594,23 @@ export class SegmentStore {
     return readFileSync(path.join(this.#root, directoryNameFor(key), makingName));
   }
 
+  /**
+   * When the encoder last wrote a file it has closed under its working name,
+   * on the kernel's clock and so apart from when this process got to it; null
+   * when it is not there.
+   *
+   * @param {string} key
+   * @param {string} makingName
+   * @returns {number | null}
+   */
+  writtenAtOf(key, makingName) {
+    try {
+      return statSync(path.join(this.#root, directoryNameFor(key), makingName)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * The media intervals a stored piece holds, read once from its bytes and kept
    * with them, or undefined where its format reads none or it is not here.