@torrent-tv/proxy 2.94.3 → 2.95.0

package/assets/calibration/NOTICE.md

@@ -17,6 +17,31 @@ H.264 High, 24 fps, 2 s each, no audio:
 | `cal-h264-480-hi.mp4` | 854×480 | 9.48 Mbit/s |
 | `cal-h264-480-lo.mp4` | 854×480 | 1.25 Mbit/s |
 
+The sets for the other codec families are made from `cal-h264-1080-hi.mp4`
+above, scaled and re-encoded with ffmpeg 8.1, 2 s, 24 fps, no audio
+(torrent-tv/meta#3). The bitrates are what the encoders produced; libxvid and
+the MPEG-2 encoder at a 9 Mbit/s target stop at their best quantizer on this
+short clip, so the high clips use a fixed quantizer instead:
+
+| file | encoder and settings | resolution | bitrate |
+|---|---|---|---|
+| `cal-mpeg4-1080-hi.mp4` | `mpeg4 -q:v 2 -bf 2 -g 48 -mbd 2` | 1920×1080 | 5.98 Mbit/s |
+| `cal-mpeg4-1080-lo.mp4` | `mpeg4 -b:v 1M -maxrate 1M -bufsize 2M -qmin 1 -bf 2 -g 48 -mbd 2` | 1920×1080 | 1.25 Mbit/s |
+| `cal-mpeg4-480-hi.mp4` | `mpeg4 -q:v 1 -qmin 1 -bf 2 -g 48 -mbd 2` | 854×480 | 3.93 Mbit/s |
+| `cal-mpeg4-480-lo.mp4` | `mpeg4 -b:v 400k -maxrate 400k -bufsize 1M -bf 2 -g 48 -mbd 2` | 854×480 | 0.54 Mbit/s |
+| `cal-mpeg2-1080-hi.mp4` | `mpeg2video -b:v 9M -maxrate 9M -bufsize 18M -qmin 1 -bf 2 -g 12` | 1920×1080 | 7.45 Mbit/s |
+| `cal-mpeg2-1080-lo.mp4` | `mpeg2video -b:v 1M -maxrate 1M -bufsize 4M -qmin 1 -bf 2 -g 12` | 1920×1080 | 2.80 Mbit/s |
+| `cal-mpeg2-480-hi.mp4` | `mpeg2video -q:v 1 -qmin 1 -bf 2 -g 12` | 854×480 | 5.95 Mbit/s |
+| `cal-mpeg2-480-lo.mp4` | `mpeg2video -b:v 500k -maxrate 500k -bufsize 2M -bf 2 -g 12` | 854×480 | 0.97 Mbit/s |
+| `cal-av1-1080-hi.mp4` | `libsvtav1 -preset 8 -b:v 9M -g 48` | 1920×1080 | 5.07 Mbit/s |
+| `cal-av1-1080-lo.mp4` | `libsvtav1 -preset 8 -b:v 1M -g 48` | 1920×1080 | 0.52 Mbit/s |
+| `cal-av1-480-hi.mp4` | `libsvtav1 -preset 8 -b:v 9M -g 48` | 854×480 | 4.38 Mbit/s |
+| `cal-av1-480-lo.mp4` | `libsvtav1 -preset 8 -b:v 1M -g 48` | 854×480 | 0.56 Mbit/s |
+
+The MPEG-4 Part 2 set is decoded by the same decoder (`mpeg4`) as an XviD or
+DivX 4+ release. VC-1 has no set because ffmpeg has no VC-1 encoder, and
+10-bit AV1 has none yet; both are priced as H.264, and the startup log says so.
+
 ## Why six, and why this grid
 
 `services/encode/hwaccel.js` decodes them at startup and fits the host's decode cost,

package/package.json

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

package/server.js

@@ -943,8 +943,6 @@ export async function startProxyServer({
       return params ? await containerOrchestrator.getTracks(params) : [];
     },
     warmKeyframeIndex: (params) => keyframeTables.warm(params),
-    expectedFirstSegmentMs: () => outputParts.hostTimings.expectedFirstSegmentMs(),
-    expectedSessionCreateMs: () => outputParts.hostTimings.expectedSessionCreateMs(),
     // The quality menu is on screen from the moment a file is opened, so the
     // heights this host can actually serve have to be answerable before any
     // encoder exists — from the probe and the startup benchmarks alone.

package/services/encode/EncodeOrchestrator.js

@@ -119,6 +119,16 @@ export class EncodeOrchestrator {
     this.#costs.noteStartup(measured);
   }
 
+  /**
+   * What a stop and a start cost on this host, in seconds, as the plan reads
+   * them — for anyone else pricing a fresh encoder by the same figures.
+   *
+   * @returns {{ killCostSec: number, firstByteWaitSec: number, samples: number }}
+   */
+  runCostSeconds() {
+    return this.#costs.seconds();
+  }
+
   /** Derived segment demand for one output, copied from the discardable cache. */
   wantedSegmentsOn(address) {
     return [...this.#demand.mapOn(address)];

package/services/encode/LocalObservations.js

@@ -41,13 +41,22 @@
  */
 
 import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { configurationKeyOf, kindOfEncoderName } from "./fingerprint.js";
 
+/**
+ * The directory of the installed proxy, where these observations are kept when
+ * the deployment names no state directory. Deliberately not the working
+ * directory: for an ordinary `npm i -g` install that is wherever the operator
+ * launched from, which would split the history between runs.
+ */
+export const PROXY_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
 /**
  * How many readings are kept per key. A history window, not a figure about the
  * machine: long enough that one run cannot decide, short enough that the
- * figure follows the host as it changes. The same length the host timings keep
- * (`quality/HostTimings.js`).
+ * figure follows the host as it changes.
  */
 const READINGS_KEPT = 20;
 

package/services/encode/OutputOpening.js

@@ -44,7 +44,7 @@ export class OutputOpening {
   #host;
 
   /**
-   * @param {object} host - `logger`, `readSourceMedia`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `admission`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
+   * @param {object} host - `logger`, `readSourceMedia`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `admission`, `outputs`, `segmentOutputFiles`, `coldStarts`, `returns`, `encodeRuns`
    * @param {SegmentOutputFiles} host.segmentOutputFiles - The storage
    *   operations needed while selecting or opening an output.
    */
@@ -627,9 +627,6 @@ export class OutputOpening {
       }
     }
 
-    // Only a session actually made is timed: a viewer joining one costs none
-    // of what this figure predicts for the next viewer who has to wait.
-    this.#host.hostTimings.rememberSessionCreateLatency(Date.now() - createEntryMs);
     const sessionId = spec.toName();
     const output = new Output({
       encodeWidth: width,
@@ -674,8 +671,8 @@ export class OutputOpening {
     this.#host.returns.note({ lastReadAt: this.#host.segmentOutputFiles.lastReadAt(spec.toKey()), now: Date.now() });
     this.#host.segmentOutputFiles.directoryFor(spec.toKey());
     this.#host.segmentOutputFiles.useFormat(spec.toKey(), segmentFormat);
-    this.#host.hostTimings.noteOutputCreated(session, createEntryMs);
-    this.#host.encodeCost.notePredictionFor(session, output.encodeHeight);
+    this.#host.coldStarts.noteOutputCreated(session, createEntryMs);
+    this.#host.encodeCost.notePredictionFor(session);
     // Decided before the key was built and only recorded here. Whether the audio
     // travels separately decides the ffmpeg arguments, what the master says,
     // whether the rendition route answers at all AND what the session is keyed

package/services/encode/SoftwareEncoder.js

@@ -19,7 +19,7 @@ import {
 /**
  * The presets the startup benchmark walks, slowest first.
  *
- * The same list `benchmarkSoftwarePresets` measures and `pickSoftwarePreset`
+ * The same list `calibrateEncoder` measures and `pickSoftwarePreset`
  * chooses from; it is stated here because it is a property of this kind, and
  * the four hardware kinds beside it show what its absence looks like.
  */
@@ -37,7 +37,7 @@ export class SoftwareEncoder extends Encoder {
       values: PRESETS,
       measured: true,
       note:
-        "Measured on every host at startup by `benchmarkSoftwarePresets`, in " +
+        "Measured on every host at startup by `calibrateEncoder`, in " +
         "pixels per second per preset, and chosen from by `pickSoftwarePreset`."
     };
   }

package/services/encode/available-share.js

@@ -1,7 +1,11 @@
 /**
  * @file How much of the machine a new encoder can actually have.
  *
- * The encoder benchmark measures a QUIET host: one ffmpeg, nothing else. A real
+ * The startup measurements are filed for a QUIET host: one ffmpeg, nothing
+ * else. The host is not quiet while they are taken, so each reading is divided
+ * by the share of the machine other work left it (`freeShareDuring`,
+ * torrent-tv/meta#3) — otherwise a reading taken while other work ran would be
+ * lowered once there and again here. A real
  * encode runs on a machine that is also downloading, hashing and serving, and
  * on the addon host that machine was measured 99 % busy — `ffmpeg=52-60%
  * proxy=17-24% system=99%` — while a step predicted at 1.83x ran at 1.01-1.12x

package/services/encode/calibration.js

@@ -196,7 +196,8 @@ export async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, run
  * @param {number} [params.segmentDurationSec]
  * @param {Array<{ width: number, height: number }>} [params.frames]
  * @param {object} [params.measure] - Replaces the three readings, for a check
- *   that must not run ffmpeg: `check`, `rawFrames`, `speed`.
+ *   that must not run ffmpeg: `check`, `rawFrames`, `speed`. `speed` answers a
+ *   number, or `{ speed, freeShare }` as `measureEncodeSlope` does.
  * @returns {Promise<{ modes: CalibratedMode[], refused: Array<{ preset: string, reason: string }> }>}
  */
 export async function calibrateEncoder({
@@ -236,6 +237,8 @@ export async function calibrateEncoder({
 
   /** @type {Map<string | null, SizeReading[]>} */
   const readings = new Map(qualified.map((rung) => [rung, []]));
+  /** The share of the machine other work left each reading. @type {number[]} */
+  const freeShares = [];
   const sortedFrames = [...frames].sort((left, right) => left.width * left.height - right.width * right.height);
   for (const frame of sortedFrames) {
     if (qualified.length === 0) {
@@ -251,7 +254,13 @@ export async function calibrateEncoder({
       // Fastest first: the ladder is slowest first, so walk it backwards.
       for (let index = qualified.length - 1; index >= 0; index -= 1) {
         const rung = qualified[index];
-        const realtimes = await speed(rung, rawPath, frame);
+        const reading = await speed(rung, rawPath, frame);
+        // A number from a check that replaces the reading; the reading itself
+        // carries the share of the machine other work left it.
+        const realtimes = typeof reading === "number" ? reading : (reading?.speed ?? null);
+        if (Number.isFinite(reading?.freeShare)) {
+          freeShares.push(reading.freeShare);
+        }
         if (realtimes === null) {
           log.warn(`calibration: ${encoder.name} "${rung ?? "as it comes"}" gave no reading at ${frame.width}x${frame.height}`);
           break;
@@ -314,6 +323,10 @@ export async function calibrateEncoder({
   log.info(
     `calibration: ${encoder.name} ${modes.length} of ${rungs.length} mode(s) usable ` +
     `(${((Date.now() - startedAt) / 1000).toFixed(1)}s)` +
+    (freeShares.length > 0
+      ? `; other work took ${Math.round((1 - Math.max(...freeShares)) * 100)}-${Math.round((1 - Math.min(...freeShares)) * 100)}% ` +
+        "of the machine during the readings, and the figures are for a machine with nothing else running"
+      : encoder.kind === "software" ? "; the machine's load during the readings was not readable, so the figures are as read" : "") +
     (refused.length > 0 ? `; not usable: ${refused.map((one) => `${one.preset} (${one.reason})`).join(", ")}` : "")
   );
   return { modes, refused };

package/services/encode/decode-cost-fit.js

@@ -337,6 +337,18 @@ export function decodeFamilyOf(source) {
   if (codec === "hevc" || codec === "h265" || codec === "x265") {
     return tenBit ? "hevc10" : "hevc";
   }
+  // ffmpeg's own names. Only what has a clip set: `msmpeg4v3` (DivX 3) is a
+  // different decoder from `mpeg4`, and 10-bit AV1 was not measured, so both
+  // fall through to H.264 like every other unmeasured codec.
+  if (codec === "mpeg4") {
+    return "mpeg4";
+  }
+  if (codec === "mpeg2video") {
+    return "mpeg2";
+  }
+  if (codec === "av1" && !tenBit) {
+    return "av1";
+  }
   return "h264";
 }
 

package/services/encode/host-load.js

@@ -171,6 +171,40 @@ export async function sampleHost(pid) {
   return { takenAt: Date.now(), processCpuSeconds, system };
 }
 
+/**
+ * The share of the machine a measured process was LEFT by everything else,
+ * between two readings taken with `sampleHost(pid)` (torrent-tv/meta#3).
+ *
+ * A startup measurement reads how fast one ffmpeg runs, and the offer later
+ * multiplies that figure by the share of the machine free at the time of the
+ * question (`available-share.js`). That is right only if the measurement itself
+ * was taken on a machine with nothing else running, which it is not: measured on
+ * the addon host on 2026-10-07, other work took 17-53 % of the four cores during
+ * the readings, and the same mode read 2.08x, 3.10x and 3.08x while ffmpeg's own
+ * processor time per second of video stayed within 3 %. Divided by this share,
+ * the three readings come to 3.60x, 3.77x and 3.79x.
+ *
+ * Null when the host does not report its load (no `/proc`), or a reading was
+ * refused; the measurement is then used as it was read, and says so.
+ *
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} before
+ * @param {{ takenAt: number, processCpuSeconds: number | null, system: object | null } | null} after
+ * @param {number} [cores]
+ * @returns {number | null} Between 0 and 1.
+ */
+export function freeShareDuring(before, after, cores = os.cpus().length) {
+  if (!before || !after) {
+    return null;
+  }
+  const shares = shareOfMachine(before, after, cores);
+  if (shares === null || shares.systemShare === null || shares.processShare === null) {
+    return null;
+  }
+  const others = Math.min(1, Math.max(0, shares.systemShare - shares.processShare));
+  const free = 1 - others;
+  return free > 0 ? free : null;
+}
+
 /**
  * How much CPU THIS process has used, across every thread it owns.
  *