@torrent-tv/proxy 2.44.0 → 2.46.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.46.0
+
+- **New**: The cost of DECODING is measured per codec family, not once on H.264. A video that has to be re-encoded is by definition one the browser could not play — HEVC, 10-bit — so the one model the host had was fitted on the codec it is least often asked about, and those decode dearer per pixel on the same box. There are now sets for HEVC 8-bit and HEVC Main 10 beside the H.264 one (`assets/calibration/`, four clips each: two sizes at two bitrates, the smallest grid that keeps the axes independent and still leaves a spare), the source's own codec and bit depth choose the constants, and a family with no set of its own is priced as H.264 — said in the log rather than left to be inferred. Measured on a desktop 2026-08-20, the same 1080p picture at ~5.8 Mbit/s: 7.7x as 8-bit HEVC against 6.3x as 10-bit, which is why ten bits is its own family and not a multiplier. AV1 has no set yet; the release survey of 2026-07-10 found it rare where HEVC was 18 %.
+- **New**: The video's bit depth is read from the probe (`parseFfmpegBitDepth`), and it travels with the source's pixel and bit rates because it decides which measurement of this host applies.
+- **Chore**: When the H.264 clips do not fit, the line now says which families did. Measured on a fast desktop the same day, the H.264 readings stopped being ordered — 1080p at 9.35 Mbit/s costing 0.0307 s/s against 720p at 9.94 costing 0.0472, which is not a thing a decoder does — so a failure there is a measurement problem and not a missing file, and the two have to be tellable apart.
+
+## 2.45.0
+
+- **Fix**: A run is cut where the PLAYER was told the cuts are. There are two boundary tables — the live one, corrected as produced segments reveal where the file's cuts truly are, and the one the playlist text was written from — and a player places every fragment by the text it holds, which never changes. The cut list handed to ffmpeg came from the live table, so every correction moved the run away from the timeline the player is reading: measured 2026-08-20 on `Minions.and.Monsters.1080p.mkv`, 119 of 125 produced segments arrived a uniform 2.002 s before the times their playlist named, against the 0.5 s hls.js bridges, and a fragment that does not land is fetched again — on 2026-08-17 two of them 1908 times each. A seek is resolved on the same table for the same reason: the time being resolved came out of that playlist. The corrections keep their purpose, which is to describe the FILE — a variant created later inherits the corrected table and publishes it, so its own playlist and its own cuts agree from the start — but they may no longer move the cuts of a session already being read.
+- **New**: `FlagDefault` is read from the container itself rather than from ffmpeg's description of it. Matroska's flag DEFAULTS TO 1 and ffmpeg has applied that default by the time it prints `(default)`, so a file whose muxer marked no subtitle track is indistinguishable in the banner from one that marked every track — and the difference is the whole question, since one means "show this" and the other means "the file has no opinion". The EBML reader already walks the Tracks element for subtitle extraction and now also records whether the element was WRITTEN. Lining the two readings up is the awkward part and it is checked rather than assumed: ffmpeg numbers `0:s:N` over every subtitle stream in container order, so position is the correspondence, but each pair must agree on language or on title — one that agrees on neither, or a differing count, and the container reading is not used at all, leaving the probe's own flags with nothing claimed for them. `mergeContainerSubtitleFlags` is pure and tested.
+- **Chore**: The line reporting a segment that began away from its grid said "the playlist says", while the figure it prints comes from the live table. Reading that log on 2026-08-20 cost a wrong diagnosis; it now says "the grid says".
+
 ## 2.44.0
 
 - **Fix**: The cues a browser is missing are found by the order they were READ, not by where they sit in the film. Cues come out of whichever clusters are downloaded, and a torrent does not arrive in film order, so the set of known cues grows in the MIDDLE as well as at the end — and the cursor shipped in 2.43.1 was a time. Measured 2026-08-20: a viewer at 272 s was answered with cues out to 1176 s, and from that moment every cue between the two was filtered away for the rest of the session, with 59 of 276 clusters read. The subtitles the viewer was about to need had become unreachable, while cues fifteen minutes ahead kept arriving. Each cue now carries the order it was found in, `?since=<n>` selects by that, and the answer states the next cursor in `X-Subtitle-Cursor`. `?after=<seconds>` still works, for a browser that has not been reloaded.

package/assets/calibration/NOTICE.md

@@ -58,6 +58,43 @@ ffmpeg's own output rather than from this table. Two rules hold, though:
 - **the axes stay independent** — every size at both bitrates. Dropping one cell
   reintroduces the collinearity that produced the zeros above.
 
-Codecs other than H.264 (HEVC, AV1, 10-bit) decode dearer per pixel, and the
-model fitted here does not describe them. Covering them means a set per codec
-family and constants chosen by the source's own codec — roadmap item 3(b).
+## One set per codec family
+
+A video that has to be RE-ENCODED is by definition one the browser could not
+play, which is to say HEVC, 10-bit or AV1 — so the model was fitted on the one
+codec it is least often asked about. There is now a set per family, and the
+source's own codec chooses the constants.
+
+| file | codec | resolution | bitrate |
+|---|---|---|---|
+| `cal-hevc-1080-hi.mp4` | HEVC Main, 8-bit | 1920×1080 | 5.78 Mbit/s |
+| `cal-hevc-1080-lo.mp4` | HEVC Main, 8-bit | 1920×1080 | 0.52 Mbit/s |
+| `cal-hevc-480-hi.mp4` | HEVC Main, 8-bit | 854×480 | 7.76 Mbit/s |
+| `cal-hevc-480-lo.mp4` | HEVC Main, 8-bit | 854×480 | 0.74 Mbit/s |
+| `cal-hevc10-1080-hi.mp4` | HEVC Main 10 | 1920×1080 | 5.82 Mbit/s |
+| `cal-hevc10-1080-lo.mp4` | HEVC Main 10 | 1920×1080 | 0.52 Mbit/s |
+| `cal-hevc10-480-hi.mp4` | HEVC Main 10 | 854×480 | 6.95 Mbit/s |
+| `cal-hevc10-480-lo.mp4` | HEVC Main 10 | 854×480 | 0.68 Mbit/s |
+
+Four per family, not six: two sizes at two bitrates is the smallest grid that
+keeps the axes independent and still leaves one spare measurement, and every
+clip costs the startup about two seconds. They are one second long rather than
+two — the benchmark loops the clip and measures a slope over about a second of
+decoding, so length beyond that buys nothing and only makes the package larger.
+
+They were cut from `cal-h264-1080-hi.mp4` rather than from the 4K master, which
+is not in this repository. Re-encoding an already-compressed picture softens its
+grain slightly; what is being measured is the cost of decoding the new
+bitstream, and the grain that survives is the same material in every set, which
+is what makes the families comparable to each other.
+
+10-bit is its own family rather than a multiplier on the 8-bit one. Wider
+samples mean wider arithmetic, and how much that costs is a property of the
+machine — which is the thing being measured. Measured on a desktop 2026-08-20,
+1080p at ~5.8 Mbit/s: 7.7x as 8-bit HEVC and 6.3x as 10-bit, so it is a real
+difference and not a rounding.
+
+AV1 has no set yet. The release survey of 2026-07-10 found it rare where HEVC
+was 18 %, so it is priced as H.264 until it is worth the startup seconds — and
+the log says which families were measured and which are falling back, rather
+than leaving it to be inferred.

package/package.json

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

package/services/container-index/matroska-subtitles.js

@@ -92,7 +92,7 @@ function readString(buffer, element) {
  *
  * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
  * @param {number} fileSize
- * @returns {Promise<{ tracks: SubtitleTrackPlan[], secondsPerTick: number, segmentDataOffset: number } | null>}
+ * @returns {Promise<{ tracks: SubtitleTrackPlan[], declared: object[], secondsPerTick: number, segmentDataOffset: number } | null>}
  */
 export async function readSubtitlePlan(readRange, fileSize) {
   const head = await readRange(0, Math.min(HEAD_BYTES, Math.max(0, fileSize - 1)));
@@ -124,6 +124,15 @@ export async function readSubtitlePlan(readRange, fileSize) {
   const tracksEnd = Math.min(head.length, tracksElement.dataOffset + tracksElement.size);
   /** @type {SubtitleTrackPlan[]} */
   const tracks = [];
+  /**
+   * Every subtitle track the file declares, in the order the Tracks element
+   * names them, text or picture. This is not for extraction — `tracks` is —
+   * but for lining ffmpeg's `0:s:N` numbering up against the container, which
+   * only holds while nothing is missing from the middle of the list.
+   *
+   * @type {Array<{ trackNumber: number, codecId: string, language: string, name: string, isDefault: boolean, declaresDefault: boolean }>}
+   */
+  const declared = [];
   for (const entry of iterateElements(head, tracksElement.dataOffset, tracksEnd)) {
     if (entry.id !== ID_TRACK_ENTRY) {
       continue;
@@ -135,7 +144,13 @@ export async function readSubtitlePlan(readRange, fileSize) {
     let language = "";
     let name = "";
     let codecPrivate = "";
+    // Matroska's `FlagDefault` DEFAULTS TO 1, so a file whose muxer wrote it on
+    // no track is indistinguishable, once the default has been applied, from
+    // one that wrote it on every track — which is how ffmpeg's banner prints it
+    // and why the banner cannot answer this. Both are kept: what the flag
+    // amounts to, and whether the file said anything at all.
     let isDefault = true;
+    let declaresDefault = false;
     for (const field of iterateElements(head, entry.dataOffset, entryEnd)) {
       if (field.id === ID_TRACK_NUMBER) {
         trackNumber = readUint(head, field.dataOffset, field.size);
@@ -149,11 +164,16 @@ export async function readSubtitlePlan(readRange, fileSize) {
         name = readString(head, field);
       } else if (field.id === ID_FLAG_DEFAULT) {
         isDefault = readUint(head, field.dataOffset, field.size) === 1;
+        declaresDefault = true;
       } else if (field.id === ID_CODEC_PRIVATE) {
         codecPrivate = head.toString("base64", field.dataOffset, field.dataOffset + field.size);
       }
     }
-    if (type !== TRACK_TYPE_SUBTITLE || trackNumber === null || !TEXT_CODECS.has(codecId)) {
+    if (type !== TRACK_TYPE_SUBTITLE || trackNumber === null) {
+      continue;
+    }
+    declared.push({ trackNumber, codecId, language, name, isDefault, declaresDefault });
+    if (!TEXT_CODECS.has(codecId)) {
       continue;
     }
     tracks.push({
@@ -167,7 +187,7 @@ export async function readSubtitlePlan(readRange, fileSize) {
     });
   }
   if (tracks.length === 0) {
-    return { tracks, secondsPerTick: scale / 1e9, segmentDataOffset: base };
+    return { tracks, declared, secondsPerTick: scale / 1e9, segmentDataOffset: base };
   }
 
   // Where the clusters holding those tracks are. A file that indexes only its
@@ -232,7 +252,7 @@ export async function readSubtitlePlan(readRange, fileSize) {
       }
     }
   }
-  return { tracks, secondsPerTick: scale / 1e9, segmentDataOffset: base };
+  return { tracks, declared, secondsPerTick: scale / 1e9, segmentDataOffset: base };
 }
 
 /**

package/services/decode-cost-fit.js

@@ -315,17 +315,49 @@ function invert(matrix) {
   return work.map((row) => row.slice(size));
 }
 
+/**
+ * Which measured family prices a source of this codec and depth.
+ *
+ * The families are the ones there are clips for. Anything else is priced as
+ * H.264 — not because it decodes like H.264, but because that is the only
+ * measurement of this host there is, and saying so in one place beats each
+ * caller inventing its own fallback.
+ *
+ * 10-bit is its own family rather than a multiplier on the 8-bit one: the
+ * samples are wider, the arithmetic is wider, and how much that costs is a
+ * property of the machine, which is what is being measured.
+ *
+ * @param {{ codec?: string | null, bitDepth?: number | null }} source
+ * @returns {string}
+ */
+export function decodeFamilyOf(source) {
+  const codec = typeof source?.codec === "string" ? source.codec.trim().toLowerCase() : "";
+  const depth = Number(source?.bitDepth);
+  const tenBit = Number.isFinite(depth) && depth >= 10;
+  if (codec === "hevc" || codec === "h265" || codec === "x265") {
+    return tenBit ? "hevc10" : "hevc";
+  }
+  return "h264";
+}
+
 /**
  * What a model prices one source at.
  *
- * @param {DecodeCostModel} model
- * @param {{ megapixelsPerSecond: number, megabitsPerSecond: number }} source
+ * The model may carry a set of per-family fits (`families`) alongside the H.264
+ * terms it also spreads at the top level, which is what a caller that knows
+ * nothing about codecs still reads. When the source names a codec and that
+ * family was measured, its own constants are used.
+ *
+ * @param {DecodeCostModel & { families?: Record<string, DecodeCostModel> }} model
+ * @param {{ megapixelsPerSecond: number, megabitsPerSecond: number, codec?: string | null, bitDepth?: number | null }} source
  * @returns {number} Seconds of work per second of content.
  */
 export function decodeCostOf(model, source) {
+  const family = decodeFamilyOf(source);
+  const terms = model?.families?.[family] ?? model;
   return (
-    model.pixelTerm * source.megapixelsPerSecond +
-    model.bitrateTerm * source.megabitsPerSecond +
-    model.constantTerm
+    terms.pixelTerm * source.megapixelsPerSecond +
+    terms.bitrateTerm * source.megabitsPerSecond +
+    terms.constantTerm
   );
 }

package/services/ffmpeg-banner.js

@@ -165,3 +165,48 @@ export function parseFfmpegHdr(stderrText) {
   // the reliable HDR signal.
   return /\b(smpte2084|arib-std-b67|arib_std_b67)\b/i.test(videoLine[0]);
 }
+
+/**
+ * How many bits per sample the video carries, from the pixel format ffmpeg
+ * prints on its `Video:` line.
+ *
+ * This is a decode-cost input, not a colour one: a 10-bit stream holds wider
+ * samples and is decoded with wider arithmetic, and how much that costs is a
+ * property of the machine. It is therefore its own calibration family rather
+ * than a multiplier on the 8-bit one.
+ *
+ * ffmpeg names the depth in the format itself — `yuv420p10le`, `yuv420p12le`,
+ * `p010le` — and omits it at 8 bits (`yuv420p`, `nv12`). An unreadable line
+ * gives null, and the caller then prices the source as 8-bit, which is what
+ * every source was priced as before this existed.
+ *
+ * @param {string} stderrText
+ * @returns {number | null}
+ */
+export function parseFfmpegBitDepth(stderrText) {
+  if (typeof stderrText !== "string" || stderrText.length === 0) {
+    return null;
+  }
+  const videoLine = stderrText.match(/Video:[^\n]*/i);
+  if (!videoLine) {
+    return null;
+  }
+  // The pixel format is the token after the codec and its tag, and the depth
+  // rides on its name. `p010`/`p016` are the two that state it without a `p`
+  // separator, and they are 10 and 16 bits.
+  const named = videoLine[0].match(/\byuv[a-z0-9]*?p(\d{1,2})(?:le|be)\b/i);
+  if (named) {
+    const depth = Number(named[1]);
+    return Number.isFinite(depth) && depth >= 8 ? depth : null;
+  }
+  if (/\bp010(?:le|be)?\b/i.test(videoLine[0])) {
+    return 10;
+  }
+  if (/\bp016(?:le|be)?\b/i.test(videoLine[0])) {
+    return 16;
+  }
+  if (/\byuv[a-z0-9]*p\b|\bnv12\b|\bnv21\b|\bgbrp\b/i.test(videoLine[0])) {
+    return 8;
+  }
+  return null;
+}

package/services/hls-session-manager.js

@@ -180,8 +180,13 @@ export function variantHeightsFor(sourceHeight) {
  * Returns null when the probe did not report enough — the budget then prices
  * the encoder alone rather than inventing a figure.
  *
- * @param {{ width: number | null, height: number | null, fps: number | null, bitrateKbps: number | null }} mediaInfo
- * @returns {{ megapixelsPerSecond: number, megabitsPerSecond: number } | null}
+ * The codec and bit depth travel with the rates because they decide WHICH
+ * measurement of this host applies: the model is fitted per codec family, and a
+ * video that has to be re-encoded is by definition one the browser could not
+ * play — HEVC, 10-bit — which is exactly where H.264 constants are wrong.
+ *
+ * @param {{ width: number | null, height: number | null, fps: number | null, bitrateKbps: number | null, codec?: string | null, bitDepth?: number | null }} mediaInfo
+ * @returns {{ megapixelsPerSecond: number, megabitsPerSecond: number, codec: string, bitDepth: number | null } | null}
  */
 export function sourceDecodeCharacteristics(mediaInfo) {
   const width = Number(mediaInfo?.width);
@@ -191,9 +196,12 @@ export function sourceDecodeCharacteristics(mediaInfo) {
   if (!(width > 0) || !(height > 0) || !(fps > 0) || !(kbps > 0)) {
     return null;
   }
+  const depth = Number(mediaInfo?.bitDepth);
   return {
     megapixelsPerSecond: (width * height * fps) / 1e6,
-    megabitsPerSecond: kbps / 1000
+    megabitsPerSecond: kbps / 1000,
+    codec: typeof mediaInfo?.codec === "string" ? mediaInfo.codec : "",
+    bitDepth: Number.isFinite(depth) && depth > 0 ? depth : null
   };
 }
 
@@ -2434,6 +2442,21 @@ export class HlsSessionManager {
    * @param {number} index
    * @returns {number}
    */
+  /**
+   * The boundary table the player is working from: the one its playlist was
+   * written from, falling back to the live table when no playlist was built
+   * from a table at all (no duration, so no synthetic playlist — and then
+   * nothing the player holds contradicts it).
+   *
+   * @param {HlsSession} session
+   * @returns {number[]}
+   */
+  publishedGridFor(session) {
+    return Array.isArray(session.publishedBoundaries) && session.publishedBoundaries.length > 0
+      ? session.publishedBoundaries
+      : (session.segmentBoundaries ?? []);
+  }
+
   #publishedStartTime(session, index) {
     const boundaries = Array.isArray(session.publishedBoundaries) && session.publishedBoundaries.length > 0
       ? session.publishedBoundaries
@@ -2486,7 +2509,10 @@ export class HlsSessionManager {
    * @returns {number}
    */
   #segmentIndexForTime(session, t) {
-    const boundaries = Array.isArray(session.segmentBoundaries) ? session.segmentBoundaries : [];
+    // The player's grid, for the same reason the cut list uses it: the time
+    // being resolved came from the playlist the player holds, so the index it
+    // means is the index that playlist gives it.
+    const boundaries = this.publishedGridFor(session);
     if (boundaries.length < 2) {
       return Math.max(0, Math.floor(t / this.segmentDurationSec));
     }
@@ -3797,8 +3823,22 @@ export class HlsSessionManager {
     // writes no self-contained pieces, so nothing could read a true start and
     // segments were stamped with times the file does not have — the 4.17 s
     // speech-against-subtitles drift, back again.
+    //
+    // Cut on the grid the PLAYER WAS GIVEN, not on the corrected one. A player
+    // places a fragment by the playlist it holds, and that text was written
+    // once and never changes; the live table keeps moving as produced segments
+    // reveal where the file's cuts really are. Cutting on the moved table makes
+    // every run faithful to a timeline nobody sent the player — measured
+    // 2026-08-20, the picture's segments arriving a uniform 2.002 s before the
+    // times the playlist named for them, which is four times what hls.js will
+    // bridge, so the fragment does not land and is asked for again.
+    //
+    // The corrections keep their purpose: they describe the file, and a variant
+    // created later inherits the corrected table and PUBLISHES it, so its own
+    // playlist and its own cuts agree from the start. What they may not do is
+    // move the cuts of a session whose playlist is already being read.
     const gridCutTimes = explicitTimes && (!session.transcodeVideo || session.cutGrid === "keyframe")
-      ? segmentCutTimesFrom(session.segmentBoundaries, safeIndex)
+      ? segmentCutTimesFrom(this.publishedGridFor(session), safeIndex)
       : null;
     // Cut times are stated on the grid, for both branches.
     //
@@ -5117,7 +5157,7 @@ export class HlsSessionManager {
         logger.warn(
         `transcode ${session.id} segment #${index} really starts at ` +
         `${trueStart.toFixed(3)}s (boundary ${at === null ? "none" : `#${at}`}), ` +
-        `the playlist says ${declaredStart.toFixed(3)}s — ` +
+        `the grid says ${declaredStart.toFixed(3)}s — ` +
         (session.audioOnly === true
           // A soundtrack is cut exactly where it was asked to be, so a
           // disagreement here is not a reading about the file at all: it is the

package/services/hwaccel.js

@@ -683,14 +683,41 @@ export async function detectTonemapSupport({ ffmpegBin, logger }) {
 // optimistic. Six points leave three spare, so the fit has a residual, and a
 // term the data does not determine can be refused instead of published as a
 // zero that looks measured. See `assets/calibration/NOTICE.md`.
-const CALIBRATION_CLIPS = [
-  "cal-h264-1080-hi.mp4",
-  "cal-h264-1080-lo.mp4",
-  "cal-h264-720-hi.mp4",
-  "cal-h264-720-lo.mp4",
-  "cal-h264-480-hi.mp4",
-  "cal-h264-480-lo.mp4"
-];
+//
+// One set PER CODEC FAMILY, because a family is what the model describes. The
+// fit used to be H.264 only, while a video that has to be RE-ENCODED is by
+// definition one the browser could not play — which is to say HEVC, 10-bit or
+// AV1 — and those decode dearer per pixel on the same box. Pricing them with
+// H.264 constants is the one case the model is always asked about and was never
+// measured on.
+//
+// A family that has no set of its own is priced with H.264's, which is what
+// happened to every family before this; the line says so rather than implying
+// it. AV1 has no set yet: the survey of 2026-07-10 found it rare where HEVC was
+// 18 % of releases, so it waits for the same treatment.
+const CALIBRATION_SETS = {
+  h264: [
+    "cal-h264-1080-hi.mp4",
+    "cal-h264-1080-lo.mp4",
+    "cal-h264-720-hi.mp4",
+    "cal-h264-720-lo.mp4",
+    "cal-h264-480-hi.mp4",
+    "cal-h264-480-lo.mp4"
+  ],
+  hevc: [
+    "cal-hevc-1080-hi.mp4",
+    "cal-hevc-1080-lo.mp4",
+    "cal-hevc-480-hi.mp4",
+    "cal-hevc-480-lo.mp4"
+  ],
+  hevc10: [
+    "cal-hevc10-1080-hi.mp4",
+    "cal-hevc10-1080-lo.mp4",
+    "cal-hevc10-480-hi.mp4",
+    "cal-hevc10-480-lo.mp4"
+  ]
+};
+const CALIBRATION_CLIPS = CALIBRATION_SETS.h264;
 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. A second of decoding is thousands of frames on a
@@ -833,13 +860,54 @@ export async function benchmarkContention({ ffmpegBin, logger, clipsDir = CALIBR
 
 export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBRATION_DIR }) {
   const log = logger ?? { info: () => {}, warn: () => {} };
+  const startedAllAt = Date.now();
+  /** @type {Record<string, { pixelTerm: number, bitrateTerm: number, constantTerm: number }>} */
+  const families = {};
+  for (const [family, clips] of Object.entries(CALIBRATION_SETS)) {
+    const fitted = await fitOneFamily({ ffmpegBin, log, clipsDir, family, clips });
+    if (fitted) {
+      families[family] = fitted;
+    }
+  }
+  if (!families.h264) {
+    // H.264 is the family every other one falls back to, so without it there is
+    // no model at all rather than a partial one. Which families DID fit is said
+    // anyway: on a fast host the H.264 clips decode at 20-80x and the readings
+    // stop being ordered — measured 2026-08-20 on a desktop, 1080p at 9.35
+    // Mbit/s costing 0.0307 s/s against 720p at 9.94 costing 0.0472, which is
+    // not a thing a decoder does — so a failure here is a measurement problem
+    // and not a missing file, and the line has to let those be told apart.
+    log.warn(
+      "hwaccel: decode cost unknown — the H.264 clips did not fit" +
+        (Object.keys(families).length > 0
+          ? `, though ${Object.keys(families).join(" and ")} did`
+          : "")
+    );
+    return null;
+  }
+  const missing = Object.keys(CALIBRATION_SETS).filter((family) => !families[family]);
+  log.info(
+    `hwaccel: decode cost measured for ${Object.keys(families).join(", ")}` +
+      (missing.length > 0 ? `; ${missing.join(" and ")} priced as H.264` : "") +
+      ` (in ${((Date.now() - startedAllAt) / 1000).toFixed(1)}s)`
+  );
+  return { families, ...families.h264 };
+}
+
+/**
+ * Fit one codec family's decode cost from its own clips.
+ *
+ * @param {{ ffmpegBin: string, log: { info: Function, warn: Function }, clipsDir: string, family: string, clips: string[] }} params
+ * @returns {Promise<{ pixelTerm: number, bitrateTerm: number, constantTerm: number } | null>}
+ */
+async function fitOneFamily({ ffmpegBin, log, clipsDir, family, clips }) {
   const startedAllAt = Date.now();
   /** @type {Array<{ megapixelsPerSecond: number, megabitsPerSecond: number, costSecondsPerSecond: number }>} */
   const samples = [];
-  for (const clip of CALIBRATION_CLIPS) {
+  for (const clip of clips) {
     const measured = await measureDecodeSlope(ffmpegBin, path.join(clipsDir, clip));
     if (!measured) {
-      log.warn(`hwaccel: decode benchmark "${clip}" failed or said nothing; decode cost unknown`);
+      log.warn(`hwaccel: decode benchmark "${clip}" failed or said nothing; ${family} not measured`);
       return null;
     }
     const cost = 1 / measured.speed;
@@ -856,11 +924,11 @@ export async function benchmarkDecodeCost({ ffmpegBin, logger, clipsDir = CALIBR
   }
   const fitted = fitDecodeCost(samples);
   if (!fitted) {
-    log.warn("hwaccel: decode cost could not be fitted to these measurements; decode cost unknown");
+    log.warn(`hwaccel: ${family} decode cost could not be fitted to these measurements`);
     return null;
   }
   log.info(
-    `hwaccel: decode cost = ${fitted.pixelTerm.toFixed(6)} × Mpx/s + ${fitted.bitrateTerm.toFixed(6)} × Mbit/s ` +
+    `hwaccel: ${family} decode cost = ${fitted.pixelTerm.toFixed(6)} × Mpx/s + ${fitted.bitrateTerm.toFixed(6)} × Mbit/s ` +
       `+ ${fitted.constantTerm.toFixed(4)} s/s (${fitted.shape} from ${fitted.samples} clips, ` +
       `typical disagreement ${fitted.residualRms.toFixed(4)} s/s` +
       // Named rather than implied: a zero in the line above means "not