@torrent-tv/proxy 2.86.0 → 2.87.0

package/services/encode/encode-run-state.js

@@ -488,45 +488,41 @@ export function declaredContainment() {
 }
 
 /**
- * Every run this session has going, earliest first.
+ * Every run in one output's registered collection, earliest first.
  *
- * A session holds as many as the machine affords, because one output can be
- * watched from more than one place: a viewer who jumps back gets a run of their
- * own rather than dragging the picture away from a viewer watching ahead.
- *
- * @param {{ runs?: Set<object> }} session
+ * @param {object[] | Set<object>} runs
  * @returns {object[]}
  */
-export function runsOf(session) {
-  const runs = session?.runs instanceof Set ? [...session.runs] : [];
-  return runs.sort((left, right) => left.from - right.from);
+export function runsOf(runs) {
+  const listed = Array.isArray(runs) ? runs : runs instanceof Set ? [...runs] : [];
+  return [...listed].sort((left, right) => left.from - right.from);
 }
 
 /**
- * The runs of this session that still have a process.
+ * The runs in one output's registered collection that still have a process.
  *
- * @param {{ runs?: Set<object> }} session
+ * @param {object[] | Set<object>} runs
  * @returns {object[]}
  */
-export function liveRunsOf(session) {
-  return runsOf(session).filter((run) => run.isAlive);
+export function liveRunsOf(runs) {
+  return runsOf(runs).filter((run) => run.isAlive);
 }
 
 /**
- * What this session's encoding is doing, as one state.
+ * What one output's registered encoders are doing, as one state.
  *
- * The most advanced state among its live runs: a session with anything
- * producing IS producing, whatever else it has going. A session that has never
+ * The most advanced state among its live runs: an output with anything
+ * producing IS producing, whatever else it has going. An output that has never
  * started a run, or whose runs have all ended, is at the table's own initial
  * state — which is what "nothing is encoding" means.
  *
- * @param {{ runs?: Set<object> }} session
+ * @param {object[] | Set<object>} runs
  * @returns {string}
  */
-export function runStateOf(session) {
+export function runStateOf(runs) {
   let answer = INITIAL_RUN_STATE;
   let rank = -1;
-  for (const run of runsOf(session)) {
+  for (const run of runsOf(runs)) {
     const at = RUN_STATE_ORDER.indexOf(run.state);
     if (at > rank) {
       rank = at;
@@ -540,7 +536,7 @@ export function runStateOf(session) {
  * How advanced a run state is, for reducing several runs to one answer.
  *
  * Producing outranks starting, and both outrank a run that has ended: what a
- * caller asking "what is this session's encoding doing" wants to know is
+ * caller asking "what is this output's encoding doing" wants to know is
  * whether anything is being made, not what the quietest of them is up to.
  */
 const RUN_STATE_ORDER = [

package/services/encode/fingerprint.js

@@ -0,0 +1,322 @@
+/**
+ * @file Which configuration a measurement of encoding was taken on (roadmap
+ * item 97, step 14).
+ *
+ * A figure about encoding is a figure about ONE configuration: this ffmpeg
+ * build, this libx264, this processor with this many threads, or this device
+ * with this driver. The same film encoded on another build or another driver
+ * is not the same measurement, and a figure kept across such a change would be
+ * applied to something it was never taken on.
+ *
+ * So every figure this proxy keeps between runs is filed under the key of the
+ * configuration it describes, and a figure whose key no longer matches is not
+ * used — not converted, not scaled, simply not matched.
+ *
+ * The key is per ENCODER, not per host. A host whose graphics driver changes
+ * keeps what it knows about its software encoder: that encoder has not
+ * changed, so nothing it was measured doing has changed either.
+ *
+ * WHAT IS READ, and where. None of it is chosen:
+ *
+ * 1. the ffmpeg build — the first line of `ffmpeg -version`;
+ * 2. the libx264 build — the version string x264 writes into every stream it
+ *    produces (`x264 - core N rNNNN hash`), read from one encoded frame;
+ * 3. the processor model and the thread count the encoder is given
+ *    (`CPU_THREADS`, which is the core count);
+ * 4. for a device-backed encoder, the device model and its driver: NVIDIA's
+ *    own tool where it exists, and otherwise what the kernel publishes under
+ *    `/sys` for the render node or the video device.
+ *
+ * A part that cannot be read is recorded as `unknown`. That is still a key:
+ * two runs that both could not read it are told apart by everything else, and
+ * a run that later can read it has a different key and starts afresh.
+ */
+
+import { spawn } from "node:child_process";
+import { readdirSync, readFileSync, readlinkSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CPU_THREADS } from "./args.js";
+
+/** What an unreadable part of a fingerprint is written as. */
+export const UNKNOWN = "unknown";
+
+/**
+ * The ffmpeg build, from the first line `ffmpeg -version` prints.
+ *
+ * @param {string} text - Standard output of `ffmpeg -version`.
+ * @returns {string}
+ */
+export function parseFfmpegVersion(text) {
+  const match = /^ffmpeg version (\S+)/m.exec(String(text ?? ""));
+  return match ? match[1] : UNKNOWN;
+}
+
+/**
+ * The libx264 build, from the text x264 writes into the stream it produces.
+ *
+ * @param {Buffer | string} bytes - An encoded H.264 stream.
+ * @returns {string}
+ */
+export function parseX264Version(bytes) {
+  const text = Buffer.isBuffer(bytes) ? bytes.toString("latin1") : String(bytes ?? "");
+  const match = /x264 - core (\d+)(?: (r\d+ [0-9a-f]+))?/.exec(text);
+  if (!match) {
+    return UNKNOWN;
+  }
+  return match[2] ? `core ${match[1]} ${match[2]}` : `core ${match[1]}`;
+}
+
+/**
+ * NVIDIA's own answer about the device and its driver.
+ *
+ * @param {string} text - `nvidia-smi --query-gpu=name,driver_version --format=csv,noheader`.
+ * @returns {{ model: string, driver: string }}
+ */
+export function parseNvidiaSmi(text) {
+  const line = String(text ?? "").split(/\r?\n/).find((row) => row.includes(","));
+  if (!line) {
+    return { model: UNKNOWN, driver: UNKNOWN };
+  }
+  const [model, driver] = line.split(",").map((value) => value.trim());
+  return { model: model || UNKNOWN, driver: driver || UNKNOWN };
+}
+
+/** ffmpeg's name for each encoder kind, as the kinds state it (`encode/*Encoder.js`). */
+const KIND_BY_NAME = Object.freeze({
+  libx264: "software",
+  h264_nvenc: "nvenc",
+  h264_qsv: "qsv",
+  h264_vaapi: "vaapi",
+  h264_v4l2m2m: "v4l2m2m"
+});
+
+/**
+ * Which kind an encoder of this name is, as an output's key names it.
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export function kindOfEncoderName(name) {
+  return KIND_BY_NAME[name] ?? UNKNOWN;
+}
+
+/**
+ * The part of a fingerprint that decides whether a figure about THIS encoder
+ * still applies. Stable text, so it can be compared and stored.
+ *
+ * @param {HostFingerprint} fingerprint
+ * @param {{ name: string, kind: string }} encoder
+ * @returns {string}
+ */
+export function configurationKeyOf(fingerprint, encoder) {
+  const common = [`ffmpeg=${fingerprint?.ffmpeg ?? UNKNOWN}`, `encoder=${encoder?.name ?? UNKNOWN}`];
+  if (encoder?.kind === "software") {
+    return [
+      ...common,
+      `x264=${fingerprint?.x264 ?? UNKNOWN}`,
+      `cpu=${fingerprint?.cpu ?? UNKNOWN}`,
+      `threads=${fingerprint?.threads ?? UNKNOWN}`
+    ].join(";");
+  }
+  const device = fingerprint?.devices?.[encoder?.kind] ?? null;
+  return [
+    ...common,
+    `device=${device?.model ?? UNKNOWN}`,
+    `driver=${device?.driver ?? UNKNOWN}`
+  ].join(";");
+}
+
+/**
+ * @typedef {object} DeviceFingerprint
+ * @property {string} model
+ * @property {string} driver
+ *
+ * @typedef {object} HostFingerprint
+ * @property {string} ffmpeg
+ * @property {string} x264
+ * @property {string} cpu
+ * @property {number} threads
+ * @property {Record<string, DeviceFingerprint>} devices - By encoder kind.
+ */
+
+/**
+ * Run a program and hand back what it wrote to standard output.
+ *
+ * @param {string} command
+ * @param {string[]} args
+ * @param {number} timeoutMs
+ * @returns {Promise<Buffer | null>} Null when it could not be run or failed.
+ */
+function capture(command, args, timeoutMs) {
+  return new Promise((resolve) => {
+    /** @type {Buffer[]} */
+    const chunks = [];
+    let settled = false;
+    let child;
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child?.kill("SIGKILL");
+      } catch {
+        // already gone
+      }
+      finish(null);
+    }, timeoutMs);
+    try {
+      child = spawn(command, args, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    } catch {
+      finish(null);
+      return;
+    }
+    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? Buffer.concat(chunks) : null));
+  });
+}
+
+/**
+ * Read a small text file, or `unknown`.
+ *
+ * @param {string} filePath
+ * @returns {string}
+ */
+function readText(filePath) {
+  try {
+    const text = readFileSync(filePath, "utf8").trim();
+    return text.length > 0 ? text : UNKNOWN;
+  } catch {
+    return UNKNOWN;
+  }
+}
+
+/**
+ * The name of the kernel driver bound to a device under `/sys`.
+ *
+ * @param {string} sysDevice - e.g. `/sys/class/drm/renderD128/device`.
+ * @returns {string}
+ */
+function driverOf(sysDevice) {
+  try {
+    return path.basename(readlinkSync(path.join(sysDevice, "driver")));
+  } catch {
+    return UNKNOWN;
+  }
+}
+
+/**
+ * The version of a kernel driver. A driver built into the kernel publishes no
+ * version of its own, and then the kernel release IS its version.
+ *
+ * @param {string} driver
+ * @returns {string}
+ */
+function driverVersionOf(driver) {
+  if (driver === UNKNOWN) {
+    return UNKNOWN;
+  }
+  const own = readText(`/sys/module/${driver}/version`);
+  return own !== UNKNOWN ? `${driver} ${own}` : `${driver} (kernel ${os.release()})`;
+}
+
+/**
+ * A render node's device: the PCI vendor and device ids, and its driver.
+ *
+ * @param {string | null} renderNode - e.g. `/dev/dri/renderD128`.
+ * @returns {DeviceFingerprint}
+ */
+function renderNodeDevice(renderNode) {
+  if (!renderNode) {
+    return { model: UNKNOWN, driver: UNKNOWN };
+  }
+  const sysDevice = `/sys/class/drm/${path.basename(renderNode)}/device`;
+  const vendor = readText(path.join(sysDevice, "vendor"));
+  const device = readText(path.join(sysDevice, "device"));
+  const model = vendor === UNKNOWN && device === UNKNOWN ? UNKNOWN : `${vendor}:${device}`;
+  return { model, driver: driverVersionOf(driverOf(sysDevice)) };
+}
+
+/**
+ * The memory-to-memory video devices, by the names the kernel gives them.
+ *
+ * @returns {DeviceFingerprint}
+ */
+function videoDevices() {
+  let names = [];
+  try {
+    names = readdirSync("/sys/class/video4linux")
+      .sort()
+      .map((entry) => readText(`/sys/class/video4linux/${entry}/name`))
+      .filter((name) => name !== UNKNOWN);
+  } catch {
+    names = [];
+  }
+  let driver = UNKNOWN;
+  try {
+    const first = readdirSync("/sys/class/video4linux").sort()[0];
+    driver = first ? driverVersionOf(driverOf(`/sys/class/video4linux/${first}/device`)) : UNKNOWN;
+  } catch {
+    driver = UNKNOWN;
+  }
+  return { model: names.length > 0 ? [...new Set(names)].join("+") : UNKNOWN, driver };
+}
+
+/**
+ * NVIDIA's device and driver, from its own tool and otherwise from the file
+ * its kernel module publishes.
+ *
+ * @returns {Promise<DeviceFingerprint>}
+ */
+async function nvidiaDevice() {
+  const smi = await capture("nvidia-smi", ["--query-gpu=name,driver_version", "--format=csv,noheader"], 5000);
+  if (smi) {
+    return parseNvidiaSmi(smi.toString("utf8"));
+  }
+  const version = readText("/proc/driver/nvidia/version");
+  const driver = /Kernel Module\s+(\S+)/.exec(version)?.[1] ?? UNKNOWN;
+  return { model: UNKNOWN, driver };
+}
+
+/**
+ * Read this host's fingerprint. Always resolves: an unreadable part is
+ * `unknown`, never a refusal to start.
+ *
+ * @param {{ ffmpegBin: string, encoder?: { kind: string, device: string | null } | null }} params
+ * @returns {Promise<HostFingerprint>}
+ */
+export async function readHostFingerprint({ ffmpegBin, encoder = null }) {
+  const versionText = await capture(ffmpegBin, ["-hide_banner", "-version"], 5000);
+  // `-hide_banner` does not hide the version line itself: it is the answer.
+  const ffmpeg = parseFfmpegVersion(versionText ? versionText.toString("utf8") : "");
+  // One frame through libx264, written to standard output: the stream carries
+  // x264's own statement of its build.
+  const oneFrame = await capture(ffmpegBin, [
+    "-hide_banner", "-loglevel", "error",
+    "-f", "lavfi", "-i", "testsrc2=s=64x64:r=1:d=1",
+    "-frames:v", "1", "-c:v", "libx264", "-f", "h264", "-"
+  ], 10000);
+  const x264 = oneFrame ? parseX264Version(oneFrame) : UNKNOWN;
+  /** @type {Record<string, DeviceFingerprint>} */
+  const devices = {};
+  if (encoder?.kind === "nvenc") {
+    devices.nvenc = await nvidiaDevice();
+  } else if (encoder?.kind === "vaapi" || encoder?.kind === "qsv") {
+    devices[encoder.kind] = renderNodeDevice(encoder.device);
+  } else if (encoder?.kind === "v4l2m2m") {
+    devices.v4l2m2m = videoDevices();
+  }
+  return {
+    ffmpeg,
+    x264,
+    cpu: os.cpus()[0]?.model?.trim() || UNKNOWN,
+    threads: CPU_THREADS,
+    devices
+  };
+}

package/services/{hwaccel.js → encode/hwaccel.js}

@@ -26,16 +26,18 @@ import { mkdtemp, readFile, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fitDecodeCost } from "./decode-cost-fit.js";
-import { penaltiesFrom } from "./encode/contention.js";
+import { penaltiesFrom } from "./contention.js";
 import { fileURLToPath } from "node:url";
 import {
   parseFfmpegBitrateKbps,
   parseFfmpegDurationSeconds,
   parseFfmpegVideoDimensions,
   parseFfmpegVideoFps
-} from "./ffmpeg-banner.js";
+} from "../media/ffmpeg-banner.js";
 
-import { keyFrameArgs, TRANSCODE_FPS } from "./encode/args.js";
+import { keyFrameArgs, TRANSCODE_FPS } from "./args.js";
+import { throughputAt } from "./throughput.js";
+import { LADDER_HEIGHTS } from "./output/ladder.js";
 // The five kinds, one class each. Detection and benchmarking stay in this file;
 // how a kind is driven belongs to the kind.
 import {
@@ -44,20 +46,37 @@ import {
   SoftwareEncoder,
   V4l2m2mEncoder,
   VaapiEncoder
-} from "./encode/index.js";
+} from "./index.js";
 // Re-exported so every caller goes on importing these figures from here:
 // the same calculation, moved to sit beside the encoder kinds built from it.
 export {
   chooseOutputFps,
   maxrateKbpsFor,
-  nominalKbpsForHeight,
-  nominalKbpsForMaxrate,
+  limitRowFor,
+  nominalKbpsFor,
   TRANSCODE_FPS
-} from "./encode/args.js";
+} from "./args.js";
 
 const BENCHMARK_REF_W = 640;
 const BENCHMARK_REF_H = 360;
 const BENCHMARK_DURATION_SEC = 3;
+/**
+ * How many raw frames a throughput reading at this size is taken over.
+ *
+ * The reference size keeps the three seconds it has always had. A larger frame
+ * gets as many frames as the same number of bytes buys, but never fewer than
+ * one second of film: the frames are looped, and a loop shorter than the
+ * encoder's reach — its reference frames and its B-frames — would let it find
+ * an identical frame to predict from and read far faster than any film.
+ *
+ * @param {{ width: number, height: number }} frame
+ * @returns {number}
+ */
+export function rawFrameCountFor(frame) {
+  const referenceBytes = BENCHMARK_REF_W * BENCHMARK_REF_H * 1.5 * TRANSCODE_FPS * BENCHMARK_DURATION_SEC;
+  const frameBytes = frame.width * frame.height * 1.5;
+  return Math.max(TRANSCODE_FPS, Math.floor(referenceBytes / frameBytes));
+}
 /**
  * The narrowest window a slope may be taken over. Measured 2026-08-15: at a
  * fifth of a second the readings were noisy enough to put `faster` and
@@ -143,7 +162,7 @@ function v4l2m2mDescriptor() {
  * @property {"software"|"vaapi"|"qsv"|"nvenc"|"v4l2m2m"} kind
  * @property {string|null} device
  * @property {string[]} inputArgs
- * @property {(opts: { targetWidth: number, targetHeight: number, segmentDurationSec: number, preset?: string, fps?: number, tonemap?: boolean, forcedKeyframeTimes?: number[] | null, nominalKbps?: number | null }) => string[]} buildVideoArgs
+ * @property {(opts: { targetWidth: number, targetHeight: number, segmentDurationSec: number, preset?: string, fps?: number, tonemap?: boolean, forcedKeyframeTimes?: number[] | null, rateControl?: { maxrateKbps: number, bufsizeKbps: number, level: string | null } | null }) => string[]} buildVideoArgs
  */
 
 /**
@@ -154,7 +173,7 @@ function v4l2m2mDescriptor() {
  * @param {number} [timeoutMs=12000]
  * @returns {Promise<{ code: number, stdout: string, stderr: string }>}
  */
-function runFfmpeg(ffmpegBin, args, timeoutMs = 12000) {
+export function runFfmpeg(ffmpegBin, args, timeoutMs = 12000) {
   return new Promise((resolve) => {
     let stdout = "";
     let stderr = "";
@@ -275,7 +294,7 @@ function buildEncoderTestArgs(descriptor, segmentDurationSec, outDir) {
     "-hls_time", String(segmentDurationSec),
     "-hls_list_size", "0",
     "-hls_flags", "independent_segments",
-    // fMP4 (CMAF) — matches the runtime pipeline (hls-session-manager).
+    // fMP4 (CMAF) — matches the runtime pipeline (`encode/run-command.js`).
     "-hls_segment_type", "fmp4",
     "-hls_fmp4_init_filename", "init.mp4",
     "-hls_segment_filename", path.join(outDir, "seg-%03d.m4s"),
@@ -294,7 +313,7 @@ function buildEncoderTestArgs(descriptor, segmentDurationSec, outDir) {
  * @param {string} outDir
  * @returns {Promise<boolean>}
  */
-async function verifySegmentsDecodeCleanly(ffmpegBin, outDir) {
+export async function verifySegmentsDecodeCleanly(ffmpegBin, outDir) {
   let files;
   try {
     files = readdirSync(outDir).filter((n) => /^seg-\d+\.m4s$/.test(n));
@@ -464,8 +483,8 @@ const CALIBRATION_SETS = {
     "cal-hevc10-480-lo.mp4"
   ]
 };
-const CALIBRATION_CLIPS = CALIBRATION_SETS.h264;
-const CALIBRATION_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "assets", "calibration");
+export const CALIBRATION_REFERENCE_CLIP = "cal-h264-1080-hi.mp4";
+export const CALIBRATION_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", "calibration");
 // How wide the measured window must be before the slope is trusted, and how
 // long to wait for it at most.
 //
@@ -1226,13 +1245,29 @@ export function canSustainOutput({
   outputPixelsPerSec,
   observedDecodeCostSec = null,
   concurrentCostSec = 0,
-  requiredSpeed = null
+  requiredSpeed = null,
+  // The frame this output is encoded at. Given, the encoder's figure is the
+  // one measured AT that size (`throughput.js`), and a size nothing was
+  // measured at is not sustainable: this host has not shown it can do it.
+  frame = null
 }) {
-  if (!Array.isArray(benchmark) || benchmark.length === 0) {
-    // Nothing measured on this host: the budget cannot refuse what it cannot
-    // price, and refusing everything would leave a viewer with no rung at all.
+  if (!Array.isArray(benchmark)) {
+    // Not calibrated at all: a wiring made without the startup calibration,
+    // which the proxy itself never is when it re-encodes (`server.js`). There is
+    // nothing to judge by, and nothing is judged.
     return { speed: null, sustainable: true };
   }
+  if (benchmark.length === 0) {
+    // CALIBRATED, and no mode of this encoder qualified (roadmap item 97, step
+    // 14). Unknown capacity is not capacity: nothing has shown this machine can
+    // hold a re-encode at all. The copied picture needs no encoder and is not
+    // asked here.
+    return { speed: null, sustainable: false };
+  }
+  const encodePixelsPerSec = cheapestPresetPixelsPerSec(benchmark, frame);
+  if (encodePixelsPerSec === null) {
+    return { speed: null, sustainable: false };
+  }
   const observed = Number.isFinite(observedDecodeCostSec) && observedDecodeCostSec > 0
     ? observedDecodeCostSec
     : null;
@@ -1244,7 +1279,7 @@ export function canSustainOutput({
   }
   const alone = predictedRealtimeSpeed({
     decodeModel,
-    encodePixelsPerSec: cheapestPresetPixelsPerSec(benchmark),
+    encodePixelsPerSec,
     outputPixelsPerSec,
     source,
     observedDecodeCostSec: observed
@@ -1278,7 +1313,7 @@ export function canSustainOutput({
  * swarm, so it survives its own supply only if what it gains between
  * interruptions covers what one interruption costs. That is measured per file
  * and per swarm by the reader — `1 + worst wait / median interval`, in
- * `supply-margin.js` — and on the field torrent of 2026-08-17 it came to 1.67
+ * `torrent/supply-margin.js` — and on the field torrent of 2026-08-17 it came to 1.67
  * against the 1.5 that used to stand here, and to 4.04-8.14 on a torrent whose
  * swarm no encoder could have kept up with.
  *
@@ -1430,7 +1465,7 @@ export function slopeOf(samples, minimumWindowSec = ENCODE_BENCHMARK_WINDOW_SEC)
   return slope <= ENCODE_BENCHMARK_MAX_PLAUSIBLE_SPEED ? slope : null;
 }
 
-function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath) {
+export function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }) {
   return new Promise((resolve) => {
     const args = [
       "-hide_banner", "-loglevel", "error", "-nostats",
@@ -1440,7 +1475,7 @@ function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath) {
       ...(typeof encoder?.benchmarkInputArgs === "function" ? encoder.benchmarkInputArgs() : []),
       "-stream_loop", "-1",
       "-f", "rawvideo", "-pix_fmt", "yuv420p",
-      "-s", `${BENCHMARK_REF_W}x${BENCHMARK_REF_H}`, "-r", String(TRANSCODE_FPS),
+      "-s", `${frame.width}x${frame.height}`, "-r", String(TRANSCODE_FPS),
       "-i", rawFramesPath,
       // THE ENCODER SAYS HOW TO MEASURE ITSELF. It was libx264 written here, so
       // a host with NVENC, QSV, VAAPI or V4L2M2M measured its encoder not at all
@@ -1523,7 +1558,7 @@ function measureEncodeSlope(ffmpegBin, encoder, rung, rawFramesPath) {
  * @param {{ info: (m: string) => void, warn: (m: string) => void }} log
  * @returns {Promise<string | null>} Path to the raw frames, or null.
  */
-async function decodeToRawFrames(ffmpegBin, log) {
+export async function decodeToRawFrames(ffmpegBin, log, frame = { width: BENCHMARK_REF_W, height: BENCHMARK_REF_H }) {
   // A benchmark may leave a host unmeasured; it may never stop it from
   // starting. Before this the temp directory was made outside any guard, so a
   // read-only or missing TMPDIR rejected the promise that starts the proxy.
@@ -1541,13 +1576,13 @@ async function decodeToRawFrames(ffmpegBin, log) {
   const args = [
     "-hide_banner", "-loglevel", "error",
     "-stream_loop", "-1",
-    "-i", path.join(CALIBRATION_DIR, CALIBRATION_CLIPS[0]),
-    "-t", String(BENCHMARK_DURATION_SEC),
-    "-vf", `scale=${BENCHMARK_REF_W}:${BENCHMARK_REF_H},fps=${TRANSCODE_FPS}`,
+    "-i", path.join(CALIBRATION_DIR, CALIBRATION_REFERENCE_CLIP),
+    "-frames:v", String(rawFrameCountFor(frame)),
+    "-vf", `scale=${frame.width}:${frame.height},fps=${TRANSCODE_FPS}`,
     "-an", "-f", "rawvideo", "-pix_fmt", "yuv420p", "-y", rawPath
   ];
   const { code } = await runFfmpeg(ffmpegBin, args, 30000);
-  const expectedBytes = BENCHMARK_REF_W * BENCHMARK_REF_H * 1.5 * TRANSCODE_FPS * BENCHMARK_DURATION_SEC;
+  const expectedBytes = frame.width * frame.height * 1.5 * rawFrameCountFor(frame);
   let written = 0;
   try {
     written = statSync(rawPath).size;
@@ -1594,11 +1629,12 @@ async function decodeToRawFrames(ffmpegBin, log) {
  * @param {Array<{ preset: string, pixelsPerSec: number }>} benchmark
  * @returns {number}
  */
-function cheapestPresetPixelsPerSec(benchmark) {
-  return benchmark[benchmark.length - 1]?.pixelsPerSec ?? 0;
+function cheapestPresetPixelsPerSec(benchmark, frame = null) {
+  const cheapest = benchmark[benchmark.length - 1];
+  return cheapest ? throughputAt(cheapest, frame) : null;
 }
 
-export function pickSoftwarePreset(benchmark, pixelsPerSecNeeded, cost = {}) {
+export function pickSoftwarePreset(benchmark, pixelsPerSecNeeded, cost = {}, frame = null) {
   if (!Array.isArray(benchmark) || benchmark.length === 0) {
     return "ultrafast";
   }
@@ -1612,9 +1648,15 @@ export function pickSoftwarePreset(benchmark, pixelsPerSecNeeded, cost = {}) {
   // always ascend with the list: on a busy machine on 2026-08-15 `faster` read
   // below `fast` twice.
   for (const entry of benchmark) {
+    // At the size this output is encoded at: a preset not measured there is
+    // not a mode this host has shown it can hold there.
+    const encodePixelsPerSec = throughputAt(entry, frame);
+    if (encodePixelsPerSec === null) {
+      continue;
+    }
     const speed = predictedRealtimeSpeed({
       decodeModel: cost.decodeModel ?? null,
-      encodePixelsPerSec: entry.pixelsPerSec,
+      encodePixelsPerSec,
       outputPixelsPerSec: pixelsPerSecNeeded,
       source: cost.source ?? null,
       observedDecodeCostSec: observed
@@ -1643,18 +1685,12 @@ function isDecodePriced(cost) {
   return Boolean(cost?.decodeModel) && Boolean(cost?.source);
 }
 
-// Resolution-ladder heights (output height rungs), high→low. The ladder is
-// derived per-stream from the ceiling (the client-requested, source-capped
-// output box): only rungs at or below the ceiling height are used, so the
-// budget never upscales past what the client asked for. Standard heights keep
-// the downscaled output at familiar resolutions.
-const RESOLUTION_LADDER_HEIGHTS = [2160, 1440, 1080, 720, 540, 480, 360, 240];
-
 /**
  * Build the resolution ladder for a ceiling box. Returns candidate output
  * dimensions from the ceiling downward, preserving the ceiling's aspect ratio,
- * each even-sized. The ceiling itself is always the top rung; ladder heights
- * at or above it are skipped (never upscale). Deduped by height.
+ * each even-sized. The ceiling itself is always the top rung; the ladder's
+ * standard heights (`LADDER_HEIGHTS`, the same list the quality menu offers) at
+ * or above it are skipped (never upscale). Deduped by height.
  *
  * @param {number} ceilingWidth
  * @param {number} ceilingHeight
@@ -1672,7 +1708,7 @@ export function buildResolutionLadder(ceilingWidth, ceilingHeight) {
   };
   /** @type {Array<{ width: number, height: number }>} */
   const rungs = [{ width: cw, height: ch }];
-  for (const h of RESOLUTION_LADDER_HEIGHTS) {
+  for (const h of LADDER_HEIGHTS) {
     if (h >= ch) {
       continue; // at/above the ceiling — the ceiling rung already covers it
     }
@@ -1714,10 +1750,14 @@ export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost
   if (ladder.length === 0) {
     return null;
   }
-  const fastest = cheapestPresetPixelsPerSec(benchmark); // the cheapest preset's throughput
   const bar = barFor(cost);
   let chosenIndex = ladder.length - 1; // default: lowest rung (best effort)
   for (let i = 0; i < ladder.length; i += 1) {
+    // The cheapest preset's throughput AT THIS RUNG's size.
+    const fastest = cheapestPresetPixelsPerSec(benchmark, ladder[i]);
+    if (fastest === null) {
+      continue;
+    }
     const speed = predictedRealtimeSpeed({
       decodeModel: cost.decodeModel ?? null,
       encodePixelsPerSec: fastest,
@@ -1730,7 +1770,7 @@ export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost
     }
   }
   const chosen = ladder[chosenIndex];
-  const preset = pickSoftwarePreset(benchmark, chosen.width * chosen.height * fps, cost);
+  const preset = pickSoftwarePreset(benchmark, chosen.width * chosen.height * fps, cost, chosen);
   return { width: chosen.width, height: chosen.height, preset, ladder, rungIndex: chosenIndex };
 }