@torrent-tv/proxy 2.81.2 → 2.82.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.82.0
+
+- **Fix**: THE ENCODER PING-PONGED BECAUSE NOTHING MEASURED WHAT A START COSTS. The plan compares when the wanted pieces appear under each arrangement, and for that it needs how long a fresh encoder takes to produce anything and how long killing one takes. Both were learned only from runs that had ENDED, so at a cold open both were zero — and zero does not read as “not measured”, it reads as “free”. Keeping a warming encoder then cost one piece and moving it cost `0 + 0 + one piece`: the same figure to the millisecond, so the tie fell to position and any advantage however small won. Field 2026-09-08: start at #68, a second later kill and start at #69, half a second later kill and start at #68 again, each dying having produced nothing. Over two days 153 runs were stopped that way and 68 of them made no segment at all.
+  **Both are measured at startup now, from one ffmpeg run**: spawn to the first piece the encoder itself announces closed, then SIGTERM to exit. 0.68 s and 0.02 s on the developer’s desktop. Readings from real runs replace them as they arrive. Worth stating because it is what the arithmetic already assumed: subtract keeping from moving and what is left is the killing plus the time the run has already lived — the warm-up a move throws away. That term exists in the formula and vanishes with the measurement, which is why the plan behaved as though a move were free.
+- **Fix**: The decode cost and the contention penalty were asked only where the chosen encoder was SOFTWARE, and neither is about the encoder. A host with a GPU decodes in software just the same — no hardware decoder is asked for anywhere — and what a second job costs is a property of the machine. So a GPU host had no decode model, no contention penalty and no encoder throughput at all, and the quality offer, which is arithmetic over those three, had nothing to compute from.
+- **New**: The throughput benchmark walks the CHOSEN encoder’s own speed ladder — libx264’s presets, NVENC’s `p1`…`p7`, QSV’s `veryfast`…`veryslow`, VAAPI’s quality levels. Each kind says how to measure itself (`Encoder.benchmarkArgs`), which is what the ladders declared and nothing ever ran. A kind with no ladder is measured once, which is still a reading where there was none.
+- **Chore**: 1000 checks pass, biome clean. NOT yet seen in the field. What the next session must show: `a start costs …s to a first piece and a stop …s on this host` once at startup, `firstByte=` and `kill=` non-zero in the very first `encode-plan` line, and no run stopped with “scores worse than standing at” an adjacent number.
+
 ## 2.81.2
 
 - **Fix**: `disk: 0MB free` on a host with 103 GB. The free space was read from the segments’ own directory, which is made when the first session starts and removed when the proxy stops — so at every start, and after every clean exit, the reading failed and answered zero, which means “no room” to everything downstream. It reads the nearest ancestor that exists; the disk is the same disk either way.

package/package.json

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

package/server.js

@@ -40,6 +40,7 @@ import { WorkerTorrentPool } from "./services/torrent-worker/pool-adapter.js";
 import { HlsSessionManager } from "./services/hls-session-manager.js";
 import { createPlaybackPlanner } from "./services/playback-planner.js";
 import { detectVideoEncoder, benchmarkSoftwarePresets, benchmarkDecodeCost, benchmarkContention, benchmarkCopySpeed, detectTonemapSupport } from "./services/hwaccel.js";
+import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
 import { logger } from "./utils/logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -126,23 +127,31 @@ export async function startProxyServer({
   const videoEncoder = transcodeAudio
     ? await detectVideoEncoder({ ffmpegBin, logger })
     : null;
-  // For software libx264, benchmark preset throughput once at startup so the
-  // session manager can pick the highest-quality preset that still encodes each
-  // stream faster than realtime. Hardware encoders use their own fixed preset.
-  // The decode model first, and the preset benchmark second — they are
-  // independent now (the presets are timed on raw frames), but the order costs
-  // nothing and keeps the two figures side by side in the log.
-  const decodeCostModel = videoEncoder?.kind === "software"
+  // WHAT THIS HOST DOES, measured before any viewer exists. Every one of these
+  // was gated on the chosen encoder being SOFTWARE, and two of the three are
+  // not about the encoder at all: a host with a GPU decodes in software just
+  // the same — no hardware decoder is asked for anywhere — and what a second
+  // job costs is a property of the machine. So a GPU host had no decode cost,
+  // no contention penalty and no encoder throughput, and the quality offer,
+  // which is arithmetic over those three, had nothing to compute from.
+  //
+  // The decode model first and the throughput second — they are independent
+  // (the rungs are timed on raw frames), but the order keeps the two figures
+  // side by side in the log.
+  const decodeCostModel = transcodeAudio
     ? await benchmarkDecodeCost({ ffmpegBin, logger })
     : null;
   // What a second job costs on this host. Measured because the budget adds
   // independent prices and this host says two jobs that each fit alone do not
   // fit together — 2.6× on the addon box (2026-08-18).
-  const contentionPenalties = videoEncoder?.kind === "software"
+  const contentionPenalties = transcodeAudio
     ? await benchmarkContention({ ffmpegBin, logger })
     : null;
-  const softwarePresetBenchmark = videoEncoder?.kind === "software"
-    ? await benchmarkSoftwarePresets({ ffmpegBin, logger })
+  // The chosen encoder walked over its OWN speed ladder: libx264's presets,
+  // NVENC's p1…p7, QSV's veryfast…veryslow, VAAPI's quality levels. A kind with
+  // no ladder is measured once, which is still a reading where there was none.
+  const softwarePresetBenchmark = videoEncoder
+    ? await benchmarkSoftwarePresets({ ffmpegBin, logger, encoder: videoEncoder })
     : null;
   // What this host does with a picture it does NOT re-encode. Every other
   // startup measurement prices encoding or decoding, and a copied picture does
@@ -155,6 +164,15 @@ export async function startProxyServer({
   const copySpeedX = transcodeAudio
     ? await benchmarkCopySpeed({ ffmpegBin, logger })
     : null;
+  // WHAT A START AND A STOP COST HERE, before any viewer exists. Both decide one
+  // thing — leave an encoder where it stands, or kill it and start another —
+  // and both used to be learned only from runs that had ENDED, so at a cold
+  // open they were zero. Zero does not read as "not measured": it reads as
+  // "free", and a free move is always taken. Field 2026-09-08: an encoder moved
+  // between two adjacent numbers every half second and produced nothing.
+  const startStopCost = transcodeAudio
+    ? await measureStartAndStop({ ffmpegBin, encoder: videoEncoder, logger })
+    : null;
   // Whether this ffmpeg build can tone-map HDR→SDR (zscale + tonemap filters).
   // Detected once; the session manager applies the tonemap chain only for HDR
   // sources on the software path when available.
@@ -171,6 +189,7 @@ export async function startProxyServer({
     decodeCostModel,
     contentionPenalties,
     copySpeedX,
+    startStopCost,
     tonemapSupported,
     segmentFormatId: segmentFormat,
     stateDir,
@@ -178,15 +197,15 @@ export async function startProxyServer({
     // CPU-bound transcode from a download-starved input before downscaling.
     // What every torrent here has moved, so the proxy can price its own
     // downloading, hashing and delivery against the machine (roadmap item 7).
-    // What the spilled pieces weigh on the torrent thread, and how to tell them
-    // their share of the disk. The owner of the disk is on this side, where the
-    // segments are; the pieces are on the other.
-    spillDisk: typeof torrentPool.allowSpillBytes === "function"
-      ? {
-          held: () => torrentPool.spilledBytes ?? 0,
-          allow: (bytes) => torrentPool.allowSpillBytes(bytes)
-        }
-      : null,
+    // What the spilled pieces weigh on the torrent thread, and how to tell them
+    // their share of the disk. The owner of the disk is on this side, where the
+    // segments are; the pieces are on the other.
+    spillDisk: typeof torrentPool.allowSpillBytes === "function"
+      ? {
+          held: () => torrentPool.spilledBytes ?? 0,
+          allow: (bytes) => torrentPool.allowSpillBytes(bytes)
+        }
+      : null,
     getTorrentTotals: async () => {
       if (typeof torrentPool.getTorrentTotals !== "function") {
         return null;

package/services/encode/Encoder.js

@@ -81,4 +81,31 @@ export class Encoder {
   buildVideoArgs(_options) {
     throw new Error(`${this.name} does not say how to build its video arguments.`);
   }
+
+  /**
+   * How to encode raw frames at one rung of this kind's speed ladder, for the
+   * startup benchmark and nothing else.
+   *
+   * SEPARATE FROM `buildVideoArgs` on purpose. That one produces a picture from
+   * a film: it scales, it tone-maps, it forces keyframes onto a grid, it caps a
+   * bitrate. The benchmark is fed raw frames of a known size and wants the
+   * encoder and the rung with nothing else in the way — otherwise the reading
+   * prices a scaler as though it were the encoder.
+   *
+   * WHY EVERY KIND MUST ANSWER IT. Until now the throughput benchmark existed
+   * only for libx264 and was gated on the chosen encoder being software, so a
+   * host with NVENC, QSV, VAAPI or V4L2M2M measured its encoder not at all —
+   * and the quality offer, which is arithmetic over pixels per second, had no
+   * pixels per second to work with. NVENC's own ladder is `p1`…`p7` and QSV's
+   * is `veryfast`…`veryslow`; both are declared here and neither was ever run.
+   *
+   * @param {string | null} rung - One value of {@link speedLadder}, or null
+   *   where the kind has no ladder and there is one thing to measure.
+   * @returns {string[]}
+   */
+  benchmarkArgs(rung = null) {
+    const ladder = this.speedLadder;
+    const setting = ladder?.flag && rung ? [ladder.flag, rung] : [];
+    return ["-c:v", this.name, ...setting];
+  }
 }

package/services/encode/QsvEncoder.js

@@ -35,6 +35,12 @@ export class QsvEncoder extends Encoder {
     };
   }
 
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    const preset = rung ? ["-preset", rung] : [];
+    return ["-c:v", "h264_qsv", "-global_quality", "24", ...preset];
+  }
+
   buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
     const { w, h } = safeDimensions(targetWidth, targetHeight);
     return [

package/services/encode/SoftwareEncoder.js

@@ -42,6 +42,11 @@ export class SoftwareEncoder extends Encoder {
     };
   }
 
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
+  }
+
   buildVideoArgs({
     targetWidth,
     targetHeight,

package/services/encode/VaapiEncoder.js

@@ -40,6 +40,14 @@ export class VaapiEncoder extends Encoder {
 
   // No fps filter: VAAPI inherits the source rate and keeps keyframes on the
   // grid via time-based -force_key_frames, so it already honours source fps.
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    // Raw frames live in this process; VAAPI encodes what is in the device, so
+    // the upload is part of what this kind costs and belongs in the reading.
+    const quality = rung ? ["-quality", rung] : [];
+    return ["-vf", "format=nv12,hwupload", "-c:v", "h264_vaapi", "-qp", "24", ...quality];
+  }
+
   buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
     const { w, h } = safeDimensions(targetWidth, targetHeight);
     return [

package/services/encode/run-costs.js

@@ -48,6 +48,40 @@ export class RunCosts {
   /** How long the first output took to appear, in milliseconds. @type {number[]} */
   #firstOutput = [];
 
+  /**
+   * What this host was measured to do at startup, before any viewer existed.
+   *
+   * WITHOUT IT BOTH FIGURES ARE ZERO AT A COLD OPEN, and zero does not read as
+   * "not measured" — it reads as "free". The whole comparison the plan makes is
+   * between leaving an encoder where it stands, which costs the remainder of its
+   * warm-up, and moving it, which costs the killing plus a warm-up from the
+   * beginning. Subtract one from the other and what is left is the killing plus
+   * the time the run has already lived — the warm-up a move throws away. Set the
+   * warm-up to zero and that difference collapses to zero as well: keeping and
+   * moving cost exactly the same, the tie falls to position, and any advantage
+   * however small wins. Field 2026-09-08: an encoder moved between two adjacent
+   * numbers every half second, produced nothing, and was killed each time.
+   *
+   * Readings from real runs replace it as they arrive; this is where the plan
+   * starts from, not where it stays.
+   *
+   * @type {{ firstByteWaitSec: number, killCostSec: number } | null}
+   */
+  #atStartup = null;
+
+  /**
+   * Take what the startup measurement found on this host.
+   *
+   * @param {{ firstByteWaitSec: number, killCostSec: number } | null} measured
+   * @returns {void}
+   */
+  noteStartup(measured) {
+    this.#atStartup =
+      Number.isFinite(measured?.firstByteWaitSec) && measured.firstByteWaitSec > 0
+        ? { firstByteWaitSec: measured.firstByteWaitSec, killCostSec: Math.max(0, measured.killCostSec ?? 0) }
+        : null;
+  }
+
   /**
    * Take the two readings a finished run carries. Either may be absent — a run
    * that was never told to stop did not die on command, and one that produced
@@ -112,8 +146,9 @@ export class RunCosts {
     // piece's encoding. Whoever uses it separates the two, because the piece
     // costs more when encoders share the machine and the spawn does not.
     return {
-      killCostSec: (middleOf(this.#dying) ?? 0) / 1000,
-      firstByteWaitSec: (middleOf(this.#firstOutput) ?? 0) / 1000,
+      killCostSec: (middleOf(this.#dying) ?? 0) / 1000 || (this.#atStartup?.killCostSec ?? 0),
+      firstByteWaitSec:
+        (middleOf(this.#firstOutput) ?? 0) / 1000 || (this.#atStartup?.firstByteWaitSec ?? 0),
       samples: Math.min(this.#dying.length, this.#firstOutput.length)
     };
   }

package/services/encode/start-stop-cost.js

@@ -0,0 +1,174 @@
+/**
+ * @file What starting and stopping an encoder costs on THIS host, measured
+ * before any viewer exists.
+ *
+ * WHY IT HAS TO BE MEASURED AT STARTUP. Both figures decide one thing: whether
+ * to leave an encoder where it stands or kill it and start another elsewhere.
+ * The plan compares when the wanted pieces appear under each arrangement, and
+ * for that it needs how long a fresh encoder takes to produce anything and how
+ * long killing one takes.
+ *
+ * Until now both were learned only from runs that had ENDED, so at a cold open
+ * they were zero — and zero does not read as "not measured", it reads as
+ * "free". A warming encoder then owed one piece and a moved one owed
+ * `0 + 0 + one piece`: the same figure to the millisecond. The tie fell to
+ * position, so any advantage however small won, and the plan moved the encoder
+ * on every pass. Field 2026-09-08, the first fifteen seconds of a session:
+ * start at #68, a second later kill and start at #69, half a second later kill
+ * and start at #68 again, each dying having produced nothing. Over two days,
+ * 153 runs stopped that way and 68 of them made no segment at all.
+ *
+ * ONE RUN GIVES BOTH READINGS. An encoder is started on a generated picture
+ * through the same pipeline a session uses, timed until it says it has closed
+ * its first piece, then killed and timed until it exits. Nothing about the
+ * measurement is chosen: it is the same encoder, the same muxer, the same
+ * channel the encoder announces finished pieces on.
+ */
+
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * How long the measurement may take before it is abandoned.
+ *
+ * Not a property of the host and not a figure anything is derived from: it
+ * bounds a startup step so a machine that cannot produce a piece at all does not
+ * hold the proxy closed. A host that hits it has said something useful — that
+ * its first piece takes longer than this — and the plan is told the bound rather
+ * than a zero.
+ */
+const GIVE_UP_AFTER_MS = 30_000;
+
+/**
+ * Measure a start and a stop on this host.
+ *
+ * @param {object} params
+ * @param {string} params.ffmpegBin
+ * @param {import("./Encoder.js").Encoder} params.encoder - The encoder this
+ *   proxy has chosen, so the reading is of the thing that will actually run.
+ * @param {number} [params.segmentDurationSec]
+ * @param {{ info: Function, warn: Function }} [params.logger]
+ * @param {() => number} [params.now]
+ * @returns {Promise<{ firstByteWaitSec: number, killCostSec: number } | null>}
+ *   Null where nothing could be measured, which is said rather than passed off
+ *   as a zero.
+ */
+export async function measureStartAndStop({
+  ffmpegBin,
+  encoder,
+  segmentDurationSec = 4,
+  logger = null,
+  now = Date.now
+}) {
+  const log = logger ?? { info: () => {}, warn: () => {} };
+  const dir = mkdtempSync(path.join(os.tmpdir(), "tt-startstop-"));
+  try {
+    const args = [
+      "-hide_banner",
+      "-nostats",
+      "-loglevel",
+      "error",
+      // A generated picture: the reading is of this host's encoder and muxer,
+      // and a file would add its own reading and its own download.
+      "-f",
+      "lavfi",
+      "-i",
+      `testsrc2=size=640x360:rate=25`,
+      "-t",
+      String(segmentDurationSec * 4),
+      // The encoder this proxy has chosen, asked for its own arguments: the
+      // reading must be of the thing that will actually run, since what a start
+      // costs is mostly the encoder opening.
+      ...(typeof encoder?.buildVideoArgs === "function"
+        ? encoder.buildVideoArgs({ targetWidth: 640, targetHeight: 360, segmentDurationSec, fps: 25 })
+        : ["-c:v", "libx264", "-preset", "ultrafast"]),
+      "-an",
+      "-f",
+      "segment",
+      "-segment_time",
+      String(segmentDurationSec),
+      // The channel the encoder names its finished pieces on — the same one a
+      // session reads, so "the first piece exists" means here what it means
+      // there.
+      "-segment_list",
+      "pipe:3",
+      "-segment_list_flags",
+      "+live",
+      "-segment_format",
+      "mp4",
+      path.join(dir, "seg-%05d.mp4")
+    ];
+
+    const spawnedAt = now();
+    const child = spawn(ffmpegBin, args, {
+      stdio: ["ignore", "ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+
+    const firstPiece = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.stdio?.[3]?.on("data", () => {
+        clearTimeout(timer);
+        resolve(now() - spawnedAt);
+      });
+      child.on("error", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+    });
+
+    if (firstPiece === null) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // Already gone.
+      }
+      log.warn("hwaccel: a start could not be measured; the plan is told so rather than told zero");
+      return null;
+    }
+
+    const killedAt = now();
+    const died = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(now() - killedAt);
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+
+    const firstByteWaitSec = firstPiece / 1000;
+    const killCostSec = died === null ? 0 : died / 1000;
+    log.info(
+      `hwaccel: a start costs ${firstByteWaitSec.toFixed(2)}s to a first piece and ` +
+      `a stop ${killCostSec.toFixed(2)}s on this host — measured before any viewer, ` +
+      "because a plan told zero reads it as free and moves an encoder for nothing"
+    );
+    return { firstByteWaitSec, killCostSec };
+  } catch (error) {
+    log.warn(
+      `hwaccel: a start and a stop could not be measured: ` +
+      `${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best effort
+    }
+  }
+}

package/services/hls-session-manager.js

@@ -1399,6 +1399,7 @@ export class HlsSessionManager {
     stateDir = "",
     segmentStore = null,
     getTorrentTotals,
+    startStopCost = null,
     spillDisk = null}) {
     this.enabled = Boolean(enabled);
     this.ffmpegBin = ffmpegBin;
@@ -1576,6 +1577,11 @@ export class HlsSessionManager {
       segmentStore: this.segmentStore,
       logger
     });
+    // What a start and a stop were measured to cost here, before any viewer
+    // existed. Without it both read zero at a cold open, and zero is not
+    // "unmeasured" — it is "free", which is what moved an encoder between two
+    // adjacent numbers every half second in the field.
+    this.encodeOrchestrator.noteStartupCosts(startStopCost);
     // Where each file is cut, held once per file and grid rather than once per
     // session. Two sessions of one film MUST agree about this to the
     // millisecond — a segment made by either has to be appendable where the