@torrent-tv/proxy 2.95.35 → 2.95.37

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -494,11 +494,13 @@ export class EncodeRuns {
     // each: 454 pieces against 401 on the field file.
     for (const [address, sessions] of byOutput) {
       const timeline = sessions[0].timeline;
+      const spec = sessions[0].spec;
       this.#host.encodeOrchestrator.notePriorityMap(
         address,
         timeline?.inSegments?.(
           this.#host.priority.mapForOutput(address),
-          Number(timeline?.segmentCount) || 0
+          Number(timeline?.segmentCount) || 0,
+          { runsPastEnd: Boolean(spec?.audio) && spec?.transcodesAudio !== true }
         ) ?? []
       );
     }

package/services/encode/OutputOpening.js

@@ -546,7 +546,13 @@ export class OutputOpening {
       encodesPicture: transcodeVideo && carriesVideo,
       exact: forceExactSize,
       target: this.#targetFor({ normalizedTargetWidth, normalizedTargetHeight, visiblePicture, sourceWidth, sourceHeight }),
-      source: { width: sourceWidth, height: sourceHeight, megabitsPerSecond: file.megabitsPerSecond, decode: file.decode },
+      source: {
+        width: sourceWidth,
+        height: sourceHeight,
+        megabitsPerSecond: file.megabitsPerSecond,
+        pictureKbps: file.pictureKbps,
+        decode: file.decode
+      },
       fps: outputFps,
       encoder: this.#host.videoEncoder,
       benchmark: this.#host.softwarePresetBenchmark,
@@ -561,7 +567,7 @@ export class OutputOpening {
         : null,
       tonemap: applyTonemap,
       capKbps,
-      limitsFor: (frame) => this.#host.limitsFor(frame),
+      limitsFor: (frame) => this.#host.limitsFor(frame, file),
       audioLoad: viewerAudio !== undefined
         ? soundtrackLoadOf(viewerAudio?.entry ?? null, viewerAudio ? viewerAudio.transcode : null)
         : soundtrackLoadOf(audioSource.entry, audioTranscoded),

package/services/encode/Renditions.js

@@ -131,7 +131,14 @@ export class Renditions {
       wanted,
       judge: (spec) => linkCouldCarry(
         linkMbps,
-        loadOf(videoLoadOfSpec(spec, base.file.megabitsPerSecond, this.#host.observedPeakMbps?.(spec) ?? null), audioLoad)
+        loadOf(
+          videoLoadOfSpec(
+            spec,
+            Number.isFinite(base.file.pictureKbps) ? base.file.pictureKbps / 1000 : null,
+            this.#host.observedPeakMbps?.(spec) ?? null
+          ),
+          audioLoad
+        )
       )
     });
   }
@@ -479,9 +486,9 @@ export class Renditions {
    * given, so a move that never completes costs them nothing.
    *
    * WHAT IS MOVED BETWEEN: outputs of the same material and the same produced
-   * size whose bounds are two neighbouring limits of `limitsFor(frame)` — the
-   * row of the frame on screen, chosen by its area, the same row the output was
-   * opened in (`output-format.js`). Down,
+   * size whose bounds are two neighbouring limits of `limitsFor(frame, file)` — the
+   * source-scaled nominal for the frame on screen, the same nominal used
+   * to open the output (`output-format.js`). Down,
    * the highest lower limit their link admits; up, the next limit only, and
    * only if their link admits it. A copy has no limit and a hardware encode is
    * given none, so neither has anywhere to move to here, and the caller's other
@@ -521,7 +528,7 @@ export class Renditions {
     if (askedHeights.length === 0) {
       return refuse("no height is chosen as the output on screen");
     }
-    const limits = this.#host.limitsFor({ width: encode.width, height: encode.height });
+    const limits = this.#host.limitsFor({ width: encode.width, height: encode.height }, base.file).filter(Number.isFinite);
     const at = limits.findIndex((limit) => maxrateKbpsFor(limit) === encode.rateControl.maxrateKbps);
     if (at < 0) {
       return refuse(`the limit on screen (maxrate ${encode.rateControl.maxrateKbps}k) is not one of ${encode.height}p's`);

package/services/encode/args.js

@@ -13,7 +13,6 @@
  */
 
 import os from "node:os";
-import { LADDER_HEIGHTS } from "./output/ladder.js";
 
 export const SOFTWARE_PRESET = "ultrafast";
 export const SOFTWARE_CRF = "24";
@@ -65,27 +64,6 @@ export function chooseOutputFps(sourceFps, cap = MAX_OUTPUT_FPS) {
 // Software x264 on weak ARM hosts is the transcode bottleneck — use all cores.
 export const CPU_THREADS = Math.max(1, os.cpus().length);
 
-// Bitrate caps (constrained CRF). CRF stays the quality driver; -maxrate/
-// -bufsize only bound the peaks. Field evidence (iPhone on cellular,
-// 2026-07-10): uncapped complex scenes produced 4 s segments of ~18 Mbit/s
-// against a 1-6 Mbit/s viewer link — 45 s prebuffer, draining buffer.
-// Nominal H.264 rates per row; multipliers from webtor's production ladder
-// (content-transcoder): maxrate = 1.3x nominal, bufsize = 1.5x. The nominal
-// figures themselves came with no source when they were written (2026-07-10,
-// openspec `adaptive-bitrate`) and stand as an assumption until roadmap item
-// 97, step 14 measures them.
-const NOMINAL_KBPS_BY_ROW = new Map([
-  [1080, 5000],
-  [720, 2800],
-  [480, 1400],
-  [360, 800],
-  [240, 400]
-]);
-// The picture every row is named after: a 16:9 frame of the row's height, as
-// the encode itself would size one (`computeOutputDimensions` from a 16:9
-// source), so the reference is the frame the product makes and not a width
-// written down beside it.
-const ROW_REFERENCE_SOURCE = Object.freeze({ width: 3840, height: 2160 });
 /**
  * The rate a re-encoded soundtrack is asked for, in kbit/s: stereo AAC. A
  * TARGET, not a bound — ffmpeg's AAC encoder lets single frames run above it
@@ -98,95 +76,25 @@ const CAP_MAXRATE_FACTOR = 1.3;
 const CAP_BUFSIZE_FACTOR = 1.5;
 
 /**
- * The rows of limits, one per height of the ladder, each with the area of the
- * frame it is named after.
- *
- * @type {{ height: number, area: number }[] | null}
- */
-let limitRows = null;
-
-/**
- * @returns {{ height: number, area: number }[]}
- */
-function rows() {
-  if (limitRows === null) {
-    limitRows = LADDER_HEIGHTS.map((height) => {
-      const frame = computeOutputDimensions(
-        ROW_REFERENCE_SOURCE.width,
-        height,
-        ROW_REFERENCE_SOURCE.width,
-        ROW_REFERENCE_SOURCE.height
-      );
-      return { height, area: frame.w * frame.h };
-    });
-  }
-  return limitRows;
-}
-
-/**
- * The row whose frame area is nearest to this one, measured as a ratio rather
- * than a difference (decided with the user 2026-09-24): a rate grows with the
- * number of points multiplicatively, and the rows stand at uneven distances, so
- * the border between two rows is the geometric mean of their areas. On the
- * border itself the row with the larger area wins, so the choice has one answer.
- *
- * Keyed by area and not by height because a height alone names the wrong
- * frame for any picture that is not 16:9: a 2.4:1 film in a 1080 box is
- * encoded at about 1920x800, 1.54 million points, which a height puts in the
- * 720 row (0.92 million) although it is nearer the 1080 row (2.07 million).
- *
- * @param {{ width: number, height: number }} frame
- * @returns {number} The height the row is named after.
- */
-export function limitRowFor({ width, height }) {
-  const area = Number(width) * Number(height);
-  if (!(Number.isFinite(area) && area > 0)) {
-    throw new RangeError(`a limit row is chosen for a frame, not for ${width}x${height}`);
-  }
-  return nearestByArea(rows(), area).height;
-}
-
-/**
- * @param {{ height: number, area: number }[]} candidates
- * @param {number} area
- * @returns {{ height: number, area: number }}
- */
-function nearestByArea(candidates, area) {
-  // The larger area over the smaller: the same order as the distance of the
-  // logarithms, without a logarithm. Taken as log(a / b) the two sides of a
-  // border come out one last digit apart — log(2/3) is not exactly -log(3/2) —
-  // and the tie rule below would never be reached.
-  const ratioTo = (rowArea) => Math.max(area, rowArea) / Math.min(area, rowArea);
-  let best = candidates[0];
-  let bestDistance = ratioTo(best.area);
-  for (const row of candidates.slice(1)) {
-    const distance = ratioTo(row.area);
-    if (distance < bestDistance || (distance === bestDistance && row.area > best.area)) {
-      best = row;
-      bestDistance = distance;
-    }
-  }
-  return best;
-}
-
-/**
- * Nominal kbps for a frame: the nominal of the row its area falls in. A row
- * that has no nominal of its own yet (540, 1440 and 2160 today) takes the one
- * of the nearest row by area that has one, by the same rule, until step 14
- * measures it.
+ * Nominal video rate for an output frame, scaled from the measured source
+ * picture rate by pixel area. Missing source facts mean no safe ceiling.
  *
  * @param {{ width: number, height: number }} frame
- * @returns {number}
+ * @param {{ width: number, height: number, pictureKbps: number | null } | null} source
+ * @returns {number | null}
  */
-export function nominalKbpsFor(frame) {
-  const row = limitRowFor(frame);
-  const own = NOMINAL_KBPS_BY_ROW.get(row);
-  if (own !== undefined) {
-    return own;
+export function nominalKbpsFor(frame, source) {
+  const width = Number(frame?.width);
+  const height = Number(frame?.height);
+  const sourceWidth = Number(source?.width);
+  const sourceHeight = Number(source?.height);
+  const pictureKbps = Number(source?.pictureKbps);
+  if (![width, height, sourceWidth, sourceHeight, pictureKbps].every(Number.isFinite) ||
+      width <= 0 || height <= 0 || sourceWidth <= 0 || sourceHeight <= 0 || pictureKbps <= 0) {
+    return null;
   }
-  const named = rows().filter((candidate) => NOMINAL_KBPS_BY_ROW.has(candidate.height));
-  const rowArea = rows().find((candidate) => candidate.height === row).area;
-  return NOMINAL_KBPS_BY_ROW.get(nearestByArea(named, rowArea).height);
+  const nominal = pictureKbps * (width * height) / (sourceWidth * sourceHeight);
+  return Number.isFinite(nominal) && nominal > 0 ? Math.round(nominal) : null;
 }
 
 /**
@@ -282,12 +190,19 @@ export function h264LevelFor({ width, height, fps, maxrateKbps, bufsizeKbps }) {
  * higher level than the one every other output of this size declares, and the
  * request would then be answered with something other than what it asked for.
  *
- * @param {{ width: number, height: number, fps: number, capKbps?: number | null }} params
- *   `capKbps` is the nominal rate asked for; absent, the size's own.
- * @returns {{ maxrateKbps: number, bufsizeKbps: number, level: string | null }}
+ * @param {{ width: number, height: number, fps: number, source: object | null, capKbps?: number | null }} params
+ *   `source` supplies source dimensions and measured picture rate. `capKbps`
+ *   is an explicit nominal limit; absent, the source-scaled rate is used.
+ * @returns {{ maxrateKbps: number, bufsizeKbps: number, level: string | null } | null}
  */
-export function softwareRateControlFor({ width, height, fps, capKbps = null }) {
-  const nominal = nominalKbpsFor({ width, height });
+export function softwareRateControlFor({ width, height, fps, source = null, capKbps = null }) {
+  const nominal = nominalKbpsFor({ width, height }, source);
+  if (nominal === null && (capKbps === null || capKbps === undefined)) {
+    return null;
+  }
+  if (nominal === null) {
+    throw new RangeError(`a bitrate limit for ${width}x${height} needs a measured source picture rate`);
+  }
   const asked = capKbps === null || capKbps === undefined ? nominal : Number(capKbps);
   if (!(Number.isFinite(asked) && asked > 0)) {
     throw new RangeError(`a bitrate limit must be a positive number of kbit/s, not ${capKbps}`);

package/services/encode/calibration.js

@@ -74,6 +74,9 @@ export const CALIBRATION_FRAMES = Object.freeze([
 
 /** The size the correctness check encodes at, and every earlier reading was taken at. */
 const CHECK_FRAME = Object.freeze({ width: 640, height: 360 });
+// Measured from the bundled 1920x1080 calibration clip with ffprobe. It has no
+// audio streams, so its whole-file rate is its picture rate.
+const CALIBRATION_SOURCE = Object.freeze({ width: 1920, height: 1080, pictureKbps: 19653 });
 
 /**
  * @typedef {object} SizeReading
@@ -121,7 +124,7 @@ export async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, run
   // Three segments' worth, so at least two are cut and each is checked alone.
   const seconds = segmentDurationSec * 3;
   const rateControl = encoder.kind === "software"
-    ? softwareRateControlFor({ ...CHECK_FRAME, fps: TRANSCODE_FPS })
+    ? softwareRateControlFor({ ...CHECK_FRAME, fps: TRANSCODE_FPS, source: CALIBRATION_SOURCE })
     : null;
   const args = [
     "-hide_banner", "-loglevel", "error",
@@ -237,6 +240,10 @@ export async function calibrateEncoder({
 
   /** @type {Map<string | null, SizeReading[]>} */
   const readings = new Map(qualified.map((rung) => [rung, []]));
+  // Each preset remains in the size walk until its own reading falls below
+  // realtime. A faster preset's result says nothing reliable about a slower
+  // preset when readings vary with load.
+  const activeRungs = new Set(qualified);
   /** 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);
@@ -254,6 +261,7 @@ 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];
+        if (!activeRungs.has(rung)) continue;
         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.
@@ -263,7 +271,8 @@ export async function calibrateEncoder({
         }
         if (realtimes === null) {
           log.warn(`calibration: ${encoder.name} "${rung ?? "as it comes"}" gave no reading at ${frame.width}x${frame.height}`);
-          break;
+          activeRungs.delete(rung);
+          continue;
         }
         readings.get(rung).push({
           width: frame.width,
@@ -274,8 +283,7 @@ export async function calibrateEncoder({
           fastestKeptUp = realtimes >= 1;
         }
         if (realtimes < 1) {
-          // Every slower mode is slower still at this size.
-          break;
+          activeRungs.delete(rung);
         }
       }
     } finally {

package/services/encode/hwaccel.js

@@ -53,7 +53,6 @@ import {
 export {
   chooseOutputFps,
   maxrateKbpsFor,
-  limitRowFor,
   nominalKbpsFor,
   TRANSCODE_FPS
 } from "./args.js";

package/services/encode/output/Timeline.js

@@ -159,10 +159,13 @@ export class Timeline {
    * @param {import("../../viewer/PriorityMap.js").PriorityMap} map - One number
    *   per second of film.
    * @param {number} segmentCount - How many pieces this output has.
+   * @param {{ runsPastEnd?: boolean }} [shape] - `runsPastEnd`: the output's
+   *   pieces copy a stream, which is cut where its packets end, so a piece
+   *   holds sound past its published end by up to one packet.
    * @returns {import("../../viewer/PriorityMap.js").DemandZone[]} Runs of pieces
    *   that agree. Empty where nothing is stated, which says nobody is coming.
    */
-  inSegments(map, segmentCount) {
+  inSegments(map, segmentCount, { runsPastEnd = false } = {}) {
     if (!(segmentCount > 0) || !map || !(map.durationSeconds > 0)) {
       return [];
     }
@@ -173,9 +176,17 @@ export class Timeline {
       // whole, so it is wanted as soon as the soonest second inside it is
       // wanted — and the piece a viewer is standing in the middle of is wanted
       // exactly as much as the second under their feet.
+      // A COPIED PIECE ALSO HOLDS THE SECOND ITS END FALLS IN. A copy ends at
+      // the first packet boundary at or after its published end, and the
+      // player places the next piece where this one truly ends (hls.js
+      // `updateFragPTSDTS` carries a parsed piece's end to every later one).
+      // Field 2026-10-09, MP3 copied out of an AVI on a 4 s grid: pieces ended
+      // up to 24 ms late, and a seek to 4000 s asked for the piece ending at
+      // 4000 s, which nothing made because second 4000 belonged to the next.
       const from = Math.max(0, Math.floor(this.publishedStartOf(index)));
+      const end = this.publishedStartOf(index + 1);
       const until = index + 1 < segmentCount
-        ? Math.max(from + 1, Math.ceil(this.publishedStartOf(index + 1)))
+        ? Math.max(from + 1, runsPastEnd ? Math.floor(end) + 1 : Math.ceil(end))
         : map.durationSeconds;
       let priority = 0;
       let withinSeconds = Number.POSITIVE_INFINITY;

package/services/encode/quality/QualityOffer.js

@@ -404,12 +404,14 @@ export class QualityOffer {
     if (!(frame.width > 0)) {
       // No source size read yet: the frame, and so its row, cannot be named,
       // and a load that cannot be named is unknown rather than a guess.
-      return videoLoadForFrame({ sourceHeight, copiesAtSource: false, sourceMbps: null, encoderKind: "" }, frame);
+      return videoLoadForFrame({ sourceWidth: 0, sourceHeight, sourcePictureKbps: null, copiesAtSource: false, sourceMbps: null, encoderKind: "" }, frame);
     }
     return videoLoadForFrame({
+      sourceWidth,
       sourceHeight,
       copiesAtSource: !base.spec.transcodesVideo,
-      sourceMbps: base.file.megabitsPerSecond,
+      sourceMbps: Number.isFinite(base.file.pictureKbps) ? base.file.pictureKbps / 1000 : null,
+      sourcePictureKbps: base.file.pictureKbps,
       encoderKind
     }, frame);
   }

package/services/encode/quality/link-budget.js

@@ -95,11 +95,10 @@ export function videoLoadOfSpec(spec, sourceMbps, observedPeakMbps = null) {
  * with no limit on a hardware one, and as the source's own stream when the
  * picture is copied at the source's height.
  *
- * The nominal limit is the one of the FRAME the height would be encoded at,
- * chosen by its area (`nominalKbpsFor`) — the same row the output is then
- * opened in, so the offer and the output cannot price one step differently.
+ * The nominal limit scales this file's measured picture rate by the output
+ * frame's area, matching the rate control used when the output is opened.
  *
- * @param {{ sourceHeight: number, copiesAtSource: boolean, sourceMbps: number | null, encoderKind: string }} picture
+ * @param {{ sourceWidth: number, sourceHeight: number, sourceMbps: number | null, sourcePictureKbps: number | null, copiesAtSource: boolean, encoderKind: string }} picture
  * @param {{ width: number, height: number }} frame - The frame this height is
  *   encoded at for this source.
  * @returns {LoadPart}
@@ -112,7 +111,12 @@ export function videoLoadForFrame(picture, frame) {
   if (picture?.encoderKind !== "software") {
     return part(null, PEAK_CLASS.UNKNOWN);
   }
-  return part(maxrateKbpsFor(nominalKbpsFor(frame)) / 1000, PEAK_CLASS.KNOWN);
+  const nominal = nominalKbpsFor(frame, {
+    width: picture.sourceWidth,
+    height: picture.sourceHeight,
+    pictureKbps: picture.sourcePictureKbps
+  });
+  return part(nominal === null ? null : maxrateKbpsFor(nominal) / 1000, PEAK_CLASS.KNOWN);
 }
 
 /**

package/services/encode/quality/output-format.js

@@ -13,10 +13,10 @@
  * 3. on a hardware encoder, or with no startup measurement, there is no ladder
  *    to choose from and the box asked for is produced.
  *
- * The rate control is part of the format: a software encode is bounded at a
- * limit from `limitsFor(frame)` — the nominal one until a set of lower limits
- * is decided — or at the limit asked for (`capKbps`), and declared at the
- * level of that size's nominal output. A hardware encoder is given no bound.
+ * The rate control is part of the format: a software encode is bounded at the
+ * source-scaled nominal from `limitsFor(frame, source)` or at the limit asked
+ * for (`capKbps`), and declared at that source and size's nominal level. A
+ * hardware encoder is given no bound. Unknown source rates mean no bound.
  *
  * AND THE VIEWER'S LINK DECIDES WHETHER IT MAY BE GIVEN AT ALL (roadmap item
  * 97, step 11). Every format considered is judged by what this viewer's link
@@ -45,7 +45,7 @@ import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoad
  * @param {boolean} params.encodesPicture - The output carries a picture and re-encodes it.
  * @param {boolean} params.exact - The size is produced exactly as asked.
  * @param {{ width: number, height: number }} params.target - The box asked for; zeroes mean the source's.
- * @param {{ width: number, height: number, megabitsPerSecond: number | null, decode: object | null }} params.source
+ * @param {{ width: number, height: number, megabitsPerSecond: number | null, pictureKbps?: number | null, decode: object | null }} params.source
  * @param {number} params.fps
  * @param {{ kind: string, name: string }} params.encoder
  * @param {unknown} params.benchmark - The startup measurement of the software encoder, or null.
@@ -56,9 +56,8 @@ import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoad
  * @param {boolean} params.tonemap
  * @param {number | null} [params.capKbps] - A nominal limit asked for outright;
  *   above the size's own it is refused (`softwareRateControlFor`).
- * @param {(frame: { width: number, height: number }) => number[]} [params.limitsFor] -
- *   The nominal limits a frame may be produced at, highest first; the row is
- *   chosen by the frame's area (`limitRowFor`).
+ * @param {(frame: { width: number, height: number }, source: object) => Array<number | null>} [params.limitsFor] -
+ *   The nominal limit derived from this source's picture rate and frame area.
  * @param {import("./link-budget.js").LoadPart | null} [params.audioLoad] - The
  *   soundtrack this viewer receives with the picture, from it or beside it.
  * @param {(encode: object | null) => OutputSpec} params.specWith - The output
@@ -85,7 +84,9 @@ export function decideOutputFormat({
   chooseBudget,
   tonemap,
   capKbps = null,
-  limitsFor = (frame) => [nominalKbpsFor(frame)],
+  limitsFor = (frame, source) => [nominalKbpsFor(frame, {
+    width: source.width, height: source.height, pictureKbps: source.pictureKbps
+  })],
   audioLoad = null,
   specWith,
   serving,
@@ -93,7 +94,11 @@ export function decideOutputFormat({
 }) {
   const judge = (spec) => linkCouldCarry(
     serving.linkMbps,
-    loadOf(videoLoadOfSpec(spec, source.megabitsPerSecond, serving.observedPeakMbps?.(spec) ?? null), audioLoad)
+    loadOf(
+      videoLoadOfSpec(spec, Number.isFinite(source.pictureKbps) ? source.pictureKbps / 1000 : null,
+        serving.observedPeakMbps?.(spec) ?? null),
+      audioLoad
+    )
   );
   const given = (spec, answer, extra = {}) => ({
     spec,
@@ -196,7 +201,7 @@ export function decideOutputFormat({
       ? [null]
       : capKbps !== null && capKbps !== undefined && w === width && h === height
         ? [capKbps]
-        : limitsFor({ width: w, height: h });
+        : limitsFor({ width: w, height: h }, source);
     return limits.map((limit) => specWith({
       encoder: encoder.name,
       width: w,
@@ -204,7 +209,7 @@ export function decideOutputFormat({
       fps,
       preset: presetFor(w, h),
       tonemap,
-      rateControl: limit === null ? null : softwareRateControlFor({ width: w, height: h, fps, capKbps: limit })
+      rateControl: limit === null ? null : softwareRateControlFor({ width: w, height: h, fps, source, capKbps: limit })
     }));
   };
   const wantedFormats = formatsAt(width, height);

package/services/media/SourceFile.js

@@ -60,6 +60,32 @@ export function sourceDecodeCharacteristics(mediaInfo) {
   };
 }
 
+/**
+ * The source picture's average rate, derived from the file rate after removing
+ * the rates stated for every embedded audio track. A missing track rate makes
+ * the picture rate unknown rather than treating the whole file rate as video.
+ *
+ * @param {{ bitrateKbps?: number | null, audioTracks?: Array<{ bitrateKbps?: number | null }> } | null} mediaInfo
+ * @returns {number | null}
+ */
+export function sourcePictureBitrateKbps(mediaInfo) {
+  const totalKbps = Number(mediaInfo?.bitrateKbps);
+  const audioTracks = mediaInfo?.audioTracks;
+  if (!(Number.isFinite(totalKbps) && totalKbps > 0) || !Array.isArray(audioTracks)) {
+    return null;
+  }
+  let audioKbps = 0;
+  for (const track of audioTracks) {
+    const rate = Number(track?.bitrateKbps);
+    if (!(Number.isFinite(rate) && rate > 0)) {
+      return null;
+    }
+    audioKbps += rate;
+  }
+  const pictureKbps = totalKbps - audioKbps;
+  return Number.isFinite(pictureKbps) && pictureKbps > 0 ? Math.round(pictureKbps) : null;
+}
+
 export class SourceFile {
   /**
    * @param {object} params
@@ -195,6 +221,11 @@ export class SourceFile {
     return Number.isFinite(kbps) && kbps > 0 ? kbps / 1000 : null;
   }
 
+  /** The source picture's average rate, or null until every required fact is known. */
+  get pictureKbps() {
+    return sourcePictureBitrateKbps(this.media);
+  }
+
   /**
    * The address this proxy's own HTTP serves this file at.
    *

package/services/media/playback-planner.js

@@ -716,6 +716,7 @@ export function createPlaybackPlanner({
           height: videoFacts.height,
           fps: videoFacts.fps,
           bitrateKbps: probe.bitrateKbps,
+          audioTracks: probe.audioTracks,
           // Which family of the decode measurement prices this source. A video
           // that has to be re-encoded is one the browser could not play, so it
           // is usually NOT H.264, and H.264 constants are wrong for it.
@@ -754,6 +755,7 @@ export function createPlaybackPlanner({
           width: videoFacts.width,
           height: videoFacts.height,
           bitrateKbps: probe.bitrateKbps,
+          audioTracks: probe.audioTracks,
           fps: videoFacts.fps,
           startTime: probe.startTimeSeconds,
           isHdr: videoFacts.isHdr,

package/services/server/wire-outputs.js

@@ -268,13 +268,10 @@ export function wireOutputs({
     const count = Number(session?.timeline?.segmentCount) || 0;
     return count > 0 && parts.segmentStore.provenNumbers(session.outputKey).length >= count;
   };
-  // The nominal limits a size may be produced at, highest first. ONE list, read
-  // by the opening of an output and by the move between limits of a height, so
-  // the two cannot disagree about which limits exist. Only the size's own until
-  // a set of lower limits is decided (roadmap item 97, step 14): a lower limit
-  // handed to a viewer must come with the page saying so. Asked with the whole
-  // frame, because the row is chosen by area (`limitRowFor`).
-  parts.limitsFor = (frame) => [nominalKbpsFor(frame)];
+  // The limit follows this file's measured picture rate and the output frame;
+  // no rate means no ceiling. The same answer is used when opening and moving
+  // between limits, so one size of one file keeps one declared H.264 level.
+  parts.limitsFor = (frame, file) => [nominalKbpsFor(frame, file)];
   // What the torrent and the proxy itself spend on this host, and how fast each watched torrent moves.
   parts.hostLoad = new HostLoad({
     readMetadataActivity,
@@ -418,7 +415,7 @@ export function wireOutputs({
     // item 97, step 12): which heights their choice is the output on screen
     // under, the segment they were last given, the move being prepared, and
     // whether a segment is closed on the output being prepared.
-    limitsFor: (frame) => parts.limitsFor(frame),
+    limitsFor: (frame, file) => parts.limitsFor(frame, file),
     heightsChosenAs: (consumerId, outputKey) => heightsChosenAs(parts.viewers, consumerId, outputKey),
     highestGivenSegmentOf: (consumerId, askedHeight) => highestGivenSegmentOf(parts.viewers, consumerId, askedHeight),
     sameHeightSwitchOf: (consumerId) => sameHeightSwitchOf(parts.viewers, consumerId),
@@ -522,7 +519,7 @@ export function wireOutputs({
     // The largest peak an output of this mode and rate control has been seen
     // carrying here: the only figure an encoder with no bound of its own has.
     observedPeakMbps: (spec) => parts.localObservations?.peakMbps(spec) ?? null,
-    limitsFor: (frame) => parts.limitsFor(frame),
+    limitsFor: (frame, file) => parts.limitsFor(frame, file),
     readSourceMedia,
     get encodeInputs() { return parts.encodeInputs; },
     get decodeCostModel() { return parts.decodeCostModel; },