@torrent-tv/proxy 2.98.19 → 2.99.1

package/package.json

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

package/server.js

@@ -66,6 +66,7 @@ import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/Nati
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
 import { directSegmentInput } from "./services/media/direct-segment-input.js";
+import { piecesRunPastEnd } from "./services/encode/output/Timeline.js";
 import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
 import { pauseCoefficient, viewerStartsOn } from "./services/viewer/PriorityMap.js";
 import { coalescing } from "./utils/coalesce.js";
@@ -626,7 +627,9 @@ export async function startProxyServer({
         const revision = outputParts.segmentStore.revisionOf(output.outputKey);
         const links = consumers.map(viewer => viewer.linkReading()?.linkMbps)
           .filter(value => Number.isFinite(value) && value > 0);
-        played.push({ outputKey: output.outputKey, grid,
+        // A piece copying a stream answers for the second its end falls in,
+        // as the encode plan reads it (`piecesRunPastEnd`).
+        played.push({ outputKey: output.outputKey, grid, runsPastEnd: piecesRunPastEnd(output.spec),
           encodeSpeed: outputParts.encodeCost.latestSpeedReadingOf(output)?.speed,
           bytesPerSecond: bytesPerSecondOf(output, revision), linkMbps: links.length ? Math.min(...links) : null,
           readyRevision: revision, ready: () => outputParts.segmentStore.sizesOf(output.outputKey),

package/services/encode/EncodeInputs.js

@@ -334,6 +334,18 @@ export class EncodeInputs {
     return rate === null || !open ? null : { bytes: Math.floor(rate * open.seconds * 1000), openMeasured: open.measured };
   }
 
+  /**
+   * What a stretch is sized from, for an output that may not exist yet: the
+   * recent copy rate in bytes per millisecond, and the memory encoder inputs
+   * may hold, each null while not known (`effective-speed.js`).
+   *
+   * @returns {{ copyBytesPerMs: number | null, capacityBytes: number | null }}
+   */
+  stretchTerms() {
+    const capacity = this.#capacity();
+    return { copyBytesPerMs: middleOf(this.#copyRates), capacityBytes: Number.isFinite(capacity) ? capacity : null };
+  }
+
   /**
    * @param {object} output
    * @returns {number | null}

package/services/encode/EncodeRuns.js

@@ -25,6 +25,7 @@ import { cutOf, cutShiftOf, judgeNeighbors, judgePiece, leadingSecondsOf, lacksO
 import { leadingPictures, presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
 import { readProcessCpuSeconds } from "./host-load.js";
+import { piecesRunPastEnd } from "./output/Timeline.js";
 
 
 /**
@@ -599,7 +600,7 @@ export class EncodeRuns {
         timeline?.inSegments?.(
           this.#host.priority.mapForOutput(address),
           Number(timeline?.segmentCount) || 0,
-          { runsPastEnd: Boolean(spec?.audio) && spec?.transcodesAudio !== true }
+          { runsPastEnd: piecesRunPastEnd(spec) }
         ) ?? []
       );
     }

package/services/encode/OutputOpening.js

@@ -120,6 +120,7 @@ export class OutputOpening {
    * @param {number}  [options.audioTrackIndex=0]        - Type-relative audio track to map (0:a:N).
    * @param {boolean} [options.exactSize=false]           - Produce the target box exactly (capped to source), with no budget downscale and no runtime downswitch. Says nothing about who asked: every rung of a master sets it.
    * @param {number | null} [options.capKbps=null]        - Nominal bitrate limit in kbit/s; null for the size's own. Above the size's own it is refused.
+   * @param {string | null} [options.preset=null]         - Speed setting of a software encode at a size produced exactly; null for the one this machine holds. Part of the output's identity.
    * @param {{ width: number, height: number } | null} [options.visiblePicture=null] - The picture as the requesting viewer sees it, in physical pixels. With no target box given, a re-encoded picture's box is the smallest rung whose frame is not smaller than this (roadmap item 98).
    * @returns {Promise<{ output: EncodedOutput, existed: boolean, audio: { trackIndex: number, transcode: boolean }, verdict: object | null }>}
    */
@@ -163,6 +164,9 @@ export class OutputOpening {
     // The nominal bitrate limit asked for, in kbit/s, or null for the size's
     // own. Part of the output's identity: another limit is another output.
     capKbps = null,
+    // The speed setting asked for, or null for the one the machine holds at
+    // the size. Named only with a size produced exactly (torrent-tv/meta#178).
+    preset = null,
     // The soundtrack THIS viewer receives with the picture — from this output
     // or beside it — as `{ transcode, entry }`. Left out, the one this
     // request names is theirs. A step opened on a viewer's behalf passes the
@@ -561,12 +565,18 @@ export class OutputOpening {
         observedDecodeCostSec: this.#host.encodeCost.decodeCostFor(file.key)?.costSec ?? null,
         requiredSpeed: this.#host.hostLoad.requiredSpeedFor(sourceKey, fileIndex)
       },
-      chooseBudget: (params) => this.#host.encodeCost.chooseEncodeBudget(params),
+      // Each mode priced over a run, its open included: the file's rate says
+      // how much film the stretch an input is sized to holds.
+      chooseBudget: (params) => this.#host.encodeCost.chooseEncodeBudget({ ...params, run: {
+        sourceBytesPerSecond: file.megabitsPerSecond > 0 ? file.megabitsPerSecond * 125000 : null,
+        segmentSeconds: this.#host.segmentDurationSec
+      } }),
       machineAdmission: this.#host.admission
         ? (candidate) => this.#host.admission.previewCandidate(candidate, file)
         : null,
       tonemap: applyTonemap,
       capKbps,
+      preset: forceExactSize ? preset : null,
       limitsFor: (frame) => this.#host.limitsFor(frame, file),
       audioLoad: viewerAudio !== undefined
         ? soundtrackLoadOf(viewerAudio?.entry ?? null, viewerAudio ? viewerAudio.transcode : null)

package/services/encode/Renditions.js

@@ -408,10 +408,10 @@ export class Renditions {
    * those would not be a step of it.
    *
    * @param {HlsSession} base
-   * @param {{ height: number, startSeconds: number, mode: "auto" | "manual", linkMbps: number | null, consumerId: string, capKbps: number | null }} params
+   * @param {{ height: number, startSeconds: number, mode: "auto" | "manual", linkMbps: number | null, consumerId: string, capKbps: number | null, preset?: string | null }} params
    * @returns {object}
    */
-  #stepOpening(base, { height, startSeconds, mode, linkMbps, consumerId, capKbps }) {
+  #stepOpening(base, { height, startSeconds, mode, linkMbps, consumerId, capKbps, preset = null }) {
     return {
       sourceKey: base.file.sourceKey,
       fileIndex: base.file.fileIndex,
@@ -442,6 +442,9 @@ export class Renditions {
       // A limit named outright, or null for the rule to choose one. Named, it
       // is answered with that limit or not at all (`output-format.js`).
       capKbps,
+      // A speed setting named outright, or null for the one this machine holds
+      // at the size (torrent-tv/meta#178).
+      preset,
       // The soundtrack THIS viewer hears, which is part of what their link
       // has to carry and need not be the one the picture was opened with.
       viewerAudio: this.#viewerAudioOf(base, consumerId),
@@ -525,6 +528,7 @@ export class Renditions {
     if (!encode || !encode.rateControl) {
       return refuse("the output on screen has no limit to change (a copy, or a hardware encode)");
     }
+    const changes = "limit";
     const askedHeights = this.#host.heightsChosenAs(consumerId, current.outputKey ?? "");
     if (askedHeights.length === 0) {
       return refuse("no height is chosen as the output on screen");
@@ -546,9 +550,9 @@ export class Renditions {
         ? `no lower limit of ${encode.height}p is admitted by this viewer's link`
         : `no higher limit of ${encode.height}p is admitted by this viewer's link, or ${encode.height}p is at its highest`);
     }
-    let prepared;
-    try {
-      prepared = await this.#host.createOrGetSession(this.#stepOpening(base, {
+    return this.#beginMove({
+      base, current, consumerId, askedHeights, direction, reasonText, changes,
+      opening: this.#stepOpening(base, {
         height: encode.height,
         startSeconds: this.#host.viewerPositionOf(base.id, consumerId),
         // Exactly the size on screen: a move between limits never changes it,
@@ -557,10 +561,124 @@ export class Renditions {
         linkMbps,
         consumerId,
         capKbps: target
-      }));
+      }),
+      what: `${encode.height}p at ${target}kbps`,
+      matches: (prepared) => prepared?.height === encode.height && prepared?.width === encode.width &&
+        prepared?.rateControl?.maxrateKbps === maxrateKbpsFor(target),
+      described: `${encode.height}p, ${target}kbps`
+    });
+  }
+
+  /**
+   * Begin moving this viewer onto another speed setting of the encoder, at the
+   * size and limit on their screen (torrent-tv/meta#178).
+   *
+   * The same move as between two limits (`prepareSameHeightSwitch`): the
+   * address does not change, and the output on their screen changes once the
+   * segment they will ask for next is closed on the new one.
+   *
+   * WHICH SETTING. Down, when this machine makes their picture slower than
+   * realtime: the best setting faster than the one on screen that this
+   * machine holds here over a run, its open included
+   * (`EncodeCost.presetSpeedOf`); a smaller picture comes after it. Up,
+   * when they have room to spare: the next better setting only, and only if
+   * this machine holds it the same way. Every setting is priced by the whole
+   * model of what its encoding costs here, never by a ratio applied to what
+   * the setting on screen was measured doing.
+   *
+   * @param {HlsSession} named - The output the browser addresses.
+   * @param {string} consumerId
+   * @param {"down" | "up"} direction
+   * @param {string} reasonText - Why, for the log.
+   * @returns {Promise<{ started: boolean, reason: string, noPlace?: boolean }>}
+   */
+  async preparePresetSwitch(named, consumerId, direction, reasonText) {
+    const base = named ? this.#host.outputs.pictureOf(named) : null;
+    const refuse = (reason) => ({ started: false, reason });
+    if (!consumerId || !base) {
+      return refuse("nobody named, or no picture");
+    }
+    if (!this.#host.outputs.publishesVariants(base)) {
+      return refuse("this stream publishes no variants");
+    }
+    if (this.#host.sameHeightSwitchOf(consumerId)) {
+      return refuse("a move is already being prepared for this viewer");
+    }
+    const current = this.#host.activeOutputFor({ base, consumerId, outputs: this.#host.outputs });
+    const encode = current?.spec?.video?.encode ?? null;
+    const ladder = this.#host.presetLadder?.() ?? [];
+    const at = encode?.preset ? ladder.indexOf(encode.preset) : -1;
+    if (!encode || at < 0) {
+      return refuse("the output on screen has no speed setting of this machine's encoder to change");
+    }
+    // A container with an init is read against the init the player fetched
+    // once, and that init holds the encoder's parameter sets, which another
+    // speed setting changes (the reference count, among others): the move
+    // would be refused at the init's check once prepared. Segments that carry
+    // their own parameter sets (MPEG-TS) have no init to disagree with.
+    if (current.segmentFormat?.initFileName) {
+      return refuse(`${current.segmentFormat.id ?? "this format"} segments are read against one init, which another speed setting does not match`);
+    }
+    const askedHeights = this.#host.heightsChosenAs(consumerId, current.outputKey ?? "");
+    if (askedHeights.length === 0) {
+      return refuse("no height is chosen as the output on screen");
+    }
+    const bar = this.#host.requiredSpeedOf?.(base) ?? 1;
+    const priced = [];
+    const holds = (preset) => {
+      const speed = this.#host.presetSpeedOf?.(current, preset) ?? null;
+      priced.push(`${preset}=${speed ? `${speed.effective.toFixed(2)}x` : "unpriced"}`);
+      return speed !== null && speed.effective >= bar;
+    };
+    // The ladder is in quality order: the faster settings come after the one on screen.
+    const target = direction === "down"
+      ? ladder.slice(at + 1).find(holds)
+      : (at > 0 && holds(ladder[at - 1]) ? ladder[at - 1] : undefined);
+    if (target === undefined) {
+      return refuse(`no ${direction === "down" ? "faster" : "better"} setting than ${encode.preset} holds ` +
+        `${bar.toFixed(2)}x at ${encode.width}x${encode.height} here (${priced.join(", ") || "none"})`);
+    }
+    // The limit on screen goes with the picture: only the setting changes.
+    const limit = encode.rateControl
+      ? this.#host.limitsFor({ width: encode.width, height: encode.height }, base.file)
+        .find((one) => Number.isFinite(one) && maxrateKbpsFor(one) === encode.rateControl.maxrateKbps) ?? null
+      : null;
+    return this.#beginMove({
+      base, current, consumerId, askedHeights, direction, changes: "preset",
+      reasonText: `${reasonText}; priced ${priced.join(", ")} against ${bar.toFixed(2)}x`,
+      opening: this.#stepOpening(base, {
+        height: encode.height,
+        startSeconds: this.#host.viewerPositionOf(base.id, consumerId),
+        mode: "manual",
+        linkMbps: this.#host.linkMbpsOf(base, consumerId),
+        consumerId,
+        capKbps: limit,
+        preset: target
+      }),
+      what: `${encode.height}p at ${target}`,
+      matches: (prepared) => prepared?.height === encode.height && prepared?.width === encode.width &&
+        prepared?.preset === target &&
+        (prepared?.rateControl?.maxrateKbps ?? null) === (encode.rateControl?.maxrateKbps ?? null),
+      described: `${encode.height}p, ${encode.preset} → ${target}`
+    });
+  }
+
+  /**
+   * The rest of a move onto another output of the size on a viewer's screen,
+   * whatever differs — the limit or the speed setting: open it, check it is
+   * what was asked, ask the machine for a place, and record the move.
+   *
+   * @param {object} move
+   * @returns {Promise<{ started: boolean, reason: string, noPlace?: boolean }>}
+   */
+  async #beginMove({ base, current, consumerId, askedHeights, direction, changes, reasonText, opening, what, matches, described }) {
+    const refuse = (reason) => ({ started: false, reason });
+    let prepared;
+    try {
+      prepared = await this.#host.createOrGetSession(opening);
     } catch (error) {
       if (error?.code === OUTPUT_UNAVAILABLE) {
-        return refuse(`the ${target}kbps output of ${encode.height}p does not suit this viewer: ${error.details?.reason ?? ""}`);
+        return refuse(`the output of ${what} does not suit this viewer: ${error.details?.reason ?? ""}`);
       }
       throw error;
     }
@@ -568,15 +686,8 @@ export class Renditions {
     if (!this.#host.encodeRuns.isLive(base) || !prepared) {
       return refuse("the picture ended while the output was being made");
     }
-    const preparedEncode = prepared.spec?.video?.encode ?? null;
-    if (
-      prepared === current ||
-      preparedEncode?.height !== encode.height ||
-      preparedEncode?.width !== encode.width ||
-      preparedEncode?.rateControl?.maxrateKbps !== maxrateKbpsFor(target) ||
-      !isSameMaterial(prepared.spec, base.spec)
-    ) {
-      return refuse(`what was opened (${prepared.outputKey}) is not ${encode.height}p at ${target}kbps of this picture`);
+    if (prepared === current || !matches(prepared.spec?.video?.encode ?? null) || !isSameMaterial(prepared.spec, base.spec)) {
+      return refuse(`what was opened (${prepared.outputKey}) is not ${what} of this picture`);
     }
     // An output whose encoding has failed for good will close no segment, so a
     // move onto it would wait for ever — and, cancelled on that failure, be
@@ -606,7 +717,7 @@ export class Renditions {
     // with the picture, and the choice about to point at it is looked up among
     // this picture's steps and not found.
     if (prepared !== base) {
-      prepared.variantHeight ??= encode.height;
+      prepared.variantHeight ??= current.spec.video.encode.height;
       this.#host.outputs.markStep(prepared);
     }
     this.#host.noteSameHeightSwitch(consumerId, {
@@ -614,6 +725,9 @@ export class Renditions {
       outputId: prepared.id,
       outputKey: prepared.outputKey ?? "",
       direction,
+      // What the move changes, which says what may undo it: a lower limit is
+      // for their link, a faster setting for this machine.
+      changes,
       reason: reasonText,
       since: Date.now()
     });
@@ -625,7 +739,7 @@ export class Renditions {
     this.#host.planEncodersSoon();
     this.#host.logger.info(
       `transcode ${base.id} preparing ${consumerId}'s move ${direction} from ${current.outputKey} to ` +
-      `${prepared.outputKey} (${encode.height}p, ${target}kbps): ${reasonText}`
+      `${prepared.outputKey} (${described}): ${reasonText}`
     );
     // It may already be made there — another viewer on it, or material kept.
     this.#reconsiderSameHeightSwitch(base, consumerId, null);
@@ -836,7 +950,7 @@ export class Renditions {
       this.#cancelSameHeightSwitch(base, consumerId, "the output being prepared no longer suits this viewer's link");
       return;
     }
-    if (move.direction === "down" && this.#suitsViewer(current, base, consumerId).suits) {
+    if (move.direction === "down" && move.changes !== "preset" && this.#suitsViewer(current, base, consumerId).suits) {
       this.#cancelSameHeightSwitch(base, consumerId, "this viewer's link carries the output on screen again");
       return;
     }

package/services/encode/output/Timeline.js

@@ -42,6 +42,27 @@
  * reveal where the file's cuts really are.
  */
 
+/**
+ * Whether an output's pieces copy a stream, picture or sound, and so may hold
+ * a little past their published end: a copy ends at the first packet boundary
+ * at or after it, and the player places the next piece where this one truly
+ * ends (hls.js `updateFragPTSDTS`). A viewer standing at a published edge is
+ * then asked for by the piece BEFORE it.
+ *
+ * Field 2026-10-09, MP3 copied out of an AVI: a seek to 4000 s asked for the
+ * piece ending at 4000 s. Field r43 (Home Assistant, 2026-10-15), a copied
+ * Matroska picture: a seek to 1000.000 s, the published start of #96, asked for
+ * #95 on both tracks; the picture's pieces were not counted as copies, nothing
+ * made #95, and the picture stood 131 s until the viewer moved
+ * (torrent-tv/meta#178).
+ *
+ * @param {{ video?: object | null, audio?: object | null, transcodesVideo?: boolean, transcodesAudio?: boolean } | null | undefined} spec
+ * @returns {boolean}
+ */
+export function piecesRunPastEnd(spec) {
+  return (Boolean(spec?.video) && spec.transcodesVideo !== true) || (Boolean(spec?.audio) && spec.transcodesAudio !== true);
+}
+
 export class Timeline {
   /**
    * @param {object} params

package/services/encode/quality/EncodeCost.js

@@ -62,6 +62,7 @@ import { computeOutputDimensions, TRANSCODE_FPS } from "../args.js";
 import { logger } from "../../../utils/logger.js";
 import { qualityStateOf } from "./OutputQualityState.js";
 import { audioReadingFor } from "../audio-work-rate.js";
+import { effectiveSpeed } from "./effective-speed.js";
 
 export class EncodeCost {
   /**
@@ -127,6 +128,54 @@ export class EncodeCost {
     }
   }
 
+  /**
+   * What this output's picture would do at another speed setting of its
+   * encoder, at the same size, on this machine as it is: the startup
+   * measurement of THAT mode at this frame, this file's decoding as measured
+   * on it, and everything else this family runs — the output itself left out,
+   * since the candidate takes its place. Then the same over a run, its open
+   * included (`effective-speed.js`), at this output's own measured open and the
+   * stretch its inputs give. No ratio between two modes is applied to the
+   * whole of FFmpeg's work: the decoding, the copy of the input and the
+   * contention do not get faster with the preset (review of r41,
+   * torrent-tv/meta#178).
+   *
+   * @param {object} session - A re-encoded picture.
+   * @param {string} preset
+   * @param {{ segmentSeconds: number }} run
+   * @returns {{ processing: number, effective: number, openSeconds: number | null, filmSeconds: number | null } | null}
+   *   Null where the mode is not measured at this size, or something running is unpriced.
+   */
+  presetSpeedOf(session, preset, { segmentSeconds }) {
+    const encode = session?.spec?.video?.encode ?? null;
+    const benchmark = this.#host().benchmark;
+    const entry = Array.isArray(benchmark) ? modeEntryFor(benchmark, preset) : null;
+    if (!encode || !entry || throughputAt(entry, { width: encode.width, height: encode.height }) === null) return null;
+    const own = processCanBeSignalled(this.#stateFor(session)) ? this.#pictureCostOf(session) : 0;
+    const processing = this.#speedOnThisMachine({
+      benchmark: [entry],
+      source: session.file?.decode ?? null,
+      width: encode.width,
+      height: encode.height,
+      fps: Number(encode.fps) || TRANSCODE_FPS,
+      observedDecodeCostSec: this.decodeCostFor(session.file?.key ?? "")?.costSec ?? null,
+      concurrentCostSec: Math.max(0, this.committedCostOf(session) - own)
+    });
+    if (!(processing > 0)) return null;
+    // WHAT THIS MODE WAS SEEN DOING HERE, alone, on material no easier than
+    // this: no better here than that. A setting a viewer was moved off for
+    // running below realtime is then not priced back above it by the model.
+    const encodeOf = { ...encode, preset };
+    const seen = correctForAvailability(this.#host().observedAloneSpeed?.({ spec: { video: { encode: encodeOf } },
+      file: session.file }), this.#host().availability);
+    const held = Number.isFinite(seen) && seen > 0 ? Math.min(processing, seen) : processing;
+    const megabits = Number(session.file?.megabitsPerSecond);
+    const shape = this.#runShapeFor({ outputKey: session.outputKey ?? null,
+      sourceBytesPerSecond: megabits > 0 ? megabits * 125000 : null, segmentSeconds });
+    return { processing: held, effective: shape ? effectiveSpeed({ processingSpeed: held, ...shape }) : held,
+      openSeconds: shape?.openSeconds ?? null, filmSeconds: shape?.filmSeconds ?? null };
+  }
+
   /**
    * The speed an encode is predicted to run at on this machine: the startup
    * measurement of the cheapest mode in `benchmark` at this size, the decode of
@@ -200,6 +249,7 @@ export class EncodeCost {
   #torrentCostSecFor;
   #runsFor;
   #stateFor;
+  #runShapeFor;
 
   /**
    * @param {{
@@ -209,10 +259,12 @@ export class EncodeCost {
    *   encodersRunningNow: () => number,
    *   torrentCostSecFor: (session: object) => number,
    *   runsFor: (output: object) => object[],
-   *   stateFor: (output: object) => string
+   *   stateFor: (output: object) => string,
+   *   runShapeFor?: (run: { outputKey: string | null, sourceBytesPerSecond: number | null, segmentSeconds: number }) =>
+   *     { openSeconds: number, filmSeconds: number } | null
    * }} deps
    */
-  constructor({ outputs, host, runningEncoders, encodersRunningNow, torrentCostSecFor, runsFor, stateFor }) {
+  constructor({ outputs, host, runningEncoders, encodersRunningNow, torrentCostSecFor, runsFor, stateFor, runShapeFor = () => null }) {
     this.#outputs = outputs;
     // Asked at the moment of the question, not copied: the share of the machine
     // that is free is re-read every few seconds, and a copy taken when this was
@@ -229,6 +281,7 @@ export class EncodeCost {
     }
     this.#runsFor = runsFor;
     this.#stateFor = stateFor;
+    this.#runShapeFor = runShapeFor;
   }
 
   /**
@@ -1092,7 +1145,15 @@ export class EncodeCost {
    * (no video transcode, hardware encoder, or missing benchmark/source size) —
    * the encode then keeps the ceiling resolution and the default preset.
    *
-   * @param {{ transcodeVideo: boolean, targetWidth: number, targetHeight: number, sourceWidth: number | null, sourceHeight: number | null, outputFps: number, source?: { megapixelsPerSecond: number, megabitsPerSecond: number } | null }} params
+   * EACH MODE IS PRICED WITH ITS RUN'S OPEN (`effective-speed.js`): a run
+   * opens its input before it encodes the stretch it is given, so a mode that
+   * encodes just above realtime falls below it over a short stretch. Priced on
+   * encoding alone, `fast` was chosen on Home Assistant at 1.03x and its runs
+   * of one piece took 5.9-7.5 s for 4 s of film (r41, torrent-tv/meta#178).
+   * `run` names the output's file rate and piece length; without it each mode
+   * is priced on encoding alone.
+   *
+   * @param {{ transcodeVideo: boolean, targetWidth: number, targetHeight: number, sourceWidth: number | null, sourceHeight: number | null, outputFps: number, source?: { megapixelsPerSecond: number, megabitsPerSecond: number } | null, run?: { sourceBytesPerSecond: number | null, segmentSeconds: number } | null }} params
    * @returns {{ width: number, height: number, preset: string } | null}
    */
   chooseEncodeBudget({
@@ -1104,7 +1165,8 @@ export class EncodeCost {
     outputFps,
     source = null,
     requiredSpeed = null,
-    observedDecodeCostSec = null
+    observedDecodeCostSec = null,
+    run = null
   }) {
     if (!transcodeVideo || this.#host().encoderKind !== "software" || !this.#host().benchmark) {
       return null;
@@ -1118,10 +1180,12 @@ export class EncodeCost {
     // opening had it and the choice priced decoding from the startup model
     // instead (review of r28, torrent-tv/meta#178).
     const decodeCostSec = Number.isFinite(observedDecodeCostSec) && observedDecodeCostSec > 0 ? observedDecodeCostSec : null;
+    // The output does not exist yet: its open is the host's (`RunCosts.openOf`).
+    const shape = run ? this.#runShapeFor({ outputKey: null, ...run }) : null;
     /** Every size and preset the choice priced, with the speed it was priced at. */
     const considered = [];
     const speedForPreset = (benchmark, frame, outputPixelsPerSec) => {
-      const speed = concurrentCostSec === null ? null : this.#speedOnThisMachine({
+      const processing = concurrentCostSec === null ? null : this.#speedOnThisMachine({
         benchmark,
         source,
         width: frame.width,
@@ -1130,7 +1194,8 @@ export class EncodeCost {
         observedDecodeCostSec: decodeCostSec,
         concurrentCostSec
       });
-      considered.push({ preset: benchmark[0]?.preset, width: frame.width, height: frame.height, speed });
+      const speed = shape ? effectiveSpeed({ processingSpeed: processing, ...shape }) : processing;
+      considered.push({ preset: benchmark[0]?.preset, width: frame.width, height: frame.height, speed, processing });
       return speed;
     };
     const choice = chooseSoftwareEncodeSettings(
@@ -1144,10 +1209,12 @@ export class EncodeCost {
     // r28, torrent-tv/meta#178).
     if (choice) {
       const availability = this.#host().availability;
-      const priced = considered.map(({ preset, width, height, speed }) =>
-        `${width}x${height} ${preset}=${Number.isFinite(speed) ? `${speed.toFixed(2)}x` : "unpriced"}`).join(", ");
+      const priced = considered.map(({ preset, width, height, speed, processing }) =>
+        `${width}x${height} ${preset}=${Number.isFinite(speed) ? `${speed.toFixed(2)}x` : "unpriced"}` +
+        (shape && Number.isFinite(processing) ? ` (${processing.toFixed(2)}x encoding)` : "")).join(", ");
+      const opened = shape ? `each run opening in ${shape.openSeconds.toFixed(2)}s for ${shape.filmSeconds.toFixed(1)}s of film; ` : "";
       logger.info(`encode choice: ${choice.width}x${choice.height}@${Number(outputFps).toFixed(3)} ${choice.preset} against ${choice.bar.toFixed(2)}x; ` +
-        `priced ${priced}; decoding ${decodeCostSec === null ? "from the startup model" : `${decodeCostSec.toFixed(4)} s per second, measured on this file`}; ` +
+        `priced ${priced}; ${opened}decoding ${decodeCostSec === null ? "from the startup model" : `${decodeCostSec.toFixed(4)} s per second, measured on this file`}; ` +
         `machine ${availability?.known ? `${Math.round(availability.share * 100)}% to spare` : "share unknown"}; ` +
         `committed work ${concurrentCostSec === null ? "unmeasured" : `${concurrentCostSec.toFixed(3)} s per second`}`);
     }

package/services/encode/quality/QualityController.js

@@ -307,6 +307,15 @@ export class QualityController {
       logger.info(`[budget] transcode ${session.id} no step up for ${consumerId}: ${move.reason}`);
       return;
     }
+    // Then a better speed setting of the same size, the way back from a move
+    // to a faster one, and the best picture of that size this machine holds
+    // (torrent-tv/meta#178).
+    if (this.#host.preparePresetSwitch) {
+      const better = await this.#host.preparePresetSwitch(session, consumerId, "up", reasonText);
+      if (better.started || better.noPlace) {
+        return;
+      }
+    }
     // One rung at a time: the lowest height above the one on screen, never
     // above the source (upscaling invents detail and costs more than the source
     // itself). A rung this host has been measured failing at is not offered
@@ -520,6 +529,15 @@ export class QualityController {
       }
       logger.info(`[budget] transcode ${session.id} ${reasonText}: no lower limit to move to (${move.reason})`);
     }
+    // For the machine, first a faster speed setting of the size on their
+    // screen, which keeps their picture's size (torrent-tv/meta#178).
+    if (machineShort && this.#host.preparePresetSwitch) {
+      const move = await this.#host.preparePresetSwitch(session, consumerId, "down", `machine-bound ${reasonText}`);
+      if (move.started) {
+        return true;
+      }
+      logger.info(`[budget] transcode ${session.id} ${reasonText}: no faster setting to move to (${move.reason})`);
+    }
     const base = this.#host.outputs.pictureOf(session);
     if (this.#askLowerHeight(session, `${linkShort ? "viewer-link-bound" : "machine-bound"} ${reasonText}`, [consumerId], {
       urgent: true,

package/services/encode/quality/effective-speed.js

@@ -0,0 +1,43 @@
+/**
+ * @file How fast a run makes film over its whole life, its open included
+ * (torrent-tv/meta#178).
+ *
+ * A run first opens its input and then encodes the stretch it was given. Over
+ * the run, film comes out at
+ *
+ *     effectiveSpeed = filmSeconds / (openSeconds + filmSeconds / processingSpeed)
+ *
+ * where `processingSpeed` is what the encoding alone does, `openSeconds` the
+ * time to its first output less that output's encoding, and `filmSeconds` the
+ * stretch it is given. A run of one piece pays the whole open for that piece:
+ * on Home Assistant (r41) runs of one 4 s piece took 5.9-7.5 s each at a
+ * processing speed priced above realtime, and the picture stood 22 times.
+ */
+
+/**
+ * @param {{ processingSpeed: number | null, openSeconds: number | null, filmSeconds: number | null }} run
+ * @returns {number | null} Null when the processing speed is not known; the
+ *   processing speed itself when the run's open or stretch is not.
+ */
+export function effectiveSpeed({ processingSpeed, openSeconds, filmSeconds }) {
+  if (!(processingSpeed > 0)) return null;
+  if (!(filmSeconds > 0) || !Number.isFinite(openSeconds) || openSeconds < 0) return processingSpeed;
+  return filmSeconds / (openSeconds + filmSeconds / processingSpeed);
+}
+
+/**
+ * The film a run is given, as the inputs size it (`EncodeInputs.stretchFor`):
+ * the copy rate times the open, within the memory inputs may hold, and one
+ * piece while no copy rate has been measured.
+ *
+ * @param {{ copyBytesPerMs: number | null, openSeconds: number, capacityBytes: number | null,
+ *   sourceBytesPerSecond: number | null, segmentSeconds: number }} params
+ * @returns {number} Seconds of film; never less than one piece.
+ */
+export function runFilmSeconds({ copyBytesPerMs, openSeconds, capacityBytes, sourceBytesPerSecond, segmentSeconds }) {
+  const piece = segmentSeconds > 0 ? segmentSeconds : 0;
+  if (!(copyBytesPerMs > 0) || !(openSeconds > 0) || !(sourceBytesPerSecond > 0)) return piece;
+  const stretch = copyBytesPerMs * openSeconds * 1000;
+  const bytes = Number.isFinite(capacityBytes) && capacityBytes >= 0 ? Math.min(stretch, capacityBytes) : stretch;
+  return Math.max(piece, bytes / sourceBytesPerSecond);
+}

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

@@ -37,6 +37,7 @@
 import { computeOutputDimensions, nominalKbpsFor, softwareRateControlFor } from "../args.js";
 import { buildResolutionLadder, canSustainOutput, pickSoftwarePreset } from "../hwaccel.js";
 import { OutputSpec } from "../output/OutputSpec.js";
+import { throughputAt } from "../throughput.js";
 import { chooseServingOutput, nextRungAreaBelow, servingCandidates } from "./serving-output.js";
 import { linkAnswerFigures, linkCouldCarry, linkRefusalReason, loadOf, videoLoadOfSpec } from "./link-budget.js";
 
@@ -56,6 +57,10 @@ 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 {string | null} [params.preset] - A speed setting asked for outright,
+ *   at a size produced exactly: a viewer moved to another mode of the size they
+ *   watch (torrent-tv/meta#178). One this encoder did not measure at that size
+ *   is not given.
  * @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
@@ -84,6 +89,7 @@ export function decideOutputFormat({
   chooseBudget,
   tonemap,
   capKbps = null,
+  preset = null,
   limitsFor = (frame, source) => [nominalKbpsFor(frame, {
     width: source.width, height: source.height, pictureKbps: source.pictureKbps
   })],
@@ -175,11 +181,19 @@ export function decideOutputFormat({
     }
     return canSustainOutput({ benchmark, ...priced, outputPixelsPerSec: w * h * fps, frame: { width: w, height: h } }).sustainable;
   };
-  const presetFor = (w, h) => (budget && w === width && h === height
-    ? budget.preset
-    : measured && w > 0
-      ? pickSoftwarePreset(benchmark, w * h * fps, priced, { width: w, height: h })
-      : null);
+  const presetNamed = typeof preset === "string" && preset.length > 0;
+  if (presetNamed && !(measured && benchmark.some((entry) => entry.preset === preset &&
+    throughputAt(entry, { width, height }) !== null))) {
+    return { ...refused(specWith(null), null, `the speed setting ${preset} is not measured at ${width}x${height} on this machine`),
+      unavailable: { reason: `the speed setting ${preset} is not measured at ${width}x${height} on this machine`, figures: null, bound: "machine" } };
+  }
+  const presetFor = (w, h) => (presetNamed && w === width && h === height
+    ? preset
+    : budget && w === width && h === height
+      ? budget.preset
+      : measured && w > 0
+        ? pickSoftwarePreset(benchmark, w * h * fps, priced, { width: w, height: h })
+        : null);
   const budgetFor = (spec) => {
     const encode = spec.video?.encode;
     if (!budget || !encode) {
@@ -226,7 +240,8 @@ export function decideOutputFormat({
   // leaving. An output with exactly this limit is still reused: it has the same
   // key, and the key is what `OutputOpening` looks up.
   const limitNamed = capKbps !== null && capKbps !== undefined;
-  if (ceiling && !limitNamed) {
+  // And so is a speed setting named: the output being left suits them too.
+  if (ceiling && !limitNamed && !presetNamed) {
     const served = chooseServingOutput({
       mode: serving.mode,
       wanted: { width, height },

package/services/server/wire-outputs.js

@@ -79,6 +79,7 @@ import { EncodeRuns } from "../encode/EncodeRuns.js";
 import { EncodeInputs } from "../encode/EncodeInputs.js";
 import { OutputTimes } from "../encode/OutputTimes.js";
 import { HostLoad } from "../encode/quality/HostLoad.js";
+import { runFilmSeconds } from "../encode/quality/effective-speed.js";
 import { ColdStarts, secondsToFirstPiece } from "../encode/quality/ColdStarts.js";
 import { BUDGET_CHECK_INTERVAL_MS, QualityController } from "../encode/quality/QualityController.js";
 import { EncodeOrchestrator } from "../encode/EncodeOrchestrator.js";
@@ -435,6 +436,14 @@ export function wireOutputs({
     // under, the segment they were last given, the move being prepared, and
     // whether a segment is closed on the output being prepared.
     limitsFor: (frame, file) => parts.limitsFor(frame, file),
+    // A move between two speed settings of the size on a viewer's screen
+    // (torrent-tv/meta#178): the settings this machine measured, in quality
+    // order; what one of them would do here for an output, over a run; and
+    // the speed this file's supply asks of it.
+    presetLadder: () => (parts.encoders.current?.kind === "software" && Array.isArray(parts.softwarePresetBenchmark)
+      ? parts.softwarePresetBenchmark.map((entry) => entry.preset) : []),
+    presetSpeedOf: (output, preset) => parts.encodeCost.presetSpeedOf(output, preset, { segmentSeconds: parts.segmentDurationSec }),
+    requiredSpeedOf: (output) => parts.hostLoad.requiredSpeedFor(output.file.sourceKey, output.file.fileIndex) ?? 1,
     heightsChosenAs: (consumerId, outputKey) => heightsChosenAs(parts.viewers, consumerId, outputKey),
     highestGivenSegmentOf: (consumerId, askedHeight) => highestGivenSegmentOf(parts.viewers, consumerId, askedHeight),
     sameHeightSwitchOf: (consumerId) => sameHeightSwitchOf(parts.viewers, consumerId),
@@ -889,6 +898,20 @@ export function wireOutputs({
     encodersRunningNow: () => parts.encodeOrchestrator.runningCount(),
     torrentCostSecFor: (session) => parts.hostLoad.torrentCostSecFor(session),
     runsFor: (session) => parts.encodeRuns.runsOf(session),
+    // A run's open and the film its input holds (`effective-speed.js`): the
+    // output's own open, else the host's, and the stretch the inputs size.
+    // Not known before a copy rate is measured: the inputs then give one
+    // piece, but a mode is chosen for the whole film, and the first runs of a
+    // cold start are short for want of bytes, not because of the mode. Priced
+    // as runs of one 4 s piece at the host's 3.21 s open, even `ultrafast` at
+    // 4.79x would make 0.99x, and the choice would fall to the lowest rung.
+    runShapeFor: ({ outputKey, sourceBytesPerSecond, segmentSeconds }) => {
+      const open = parts.encodeOrchestrator?.openOf(outputKey ?? "") ?? null;
+      const { copyBytesPerMs = null, capacityBytes = null } = parts.encodeInputs?.stretchTerms?.() ?? {};
+      if (!open || !(copyBytesPerMs > 0)) return null;
+      return { openSeconds: open.seconds,
+        filmSeconds: runFilmSeconds({ copyBytesPerMs, openSeconds: open.seconds, capacityBytes, sourceBytesPerSecond, segmentSeconds }) };
+    },
     stateFor: (session) => parts.encodeRuns.runStateOf(session)
   });
   // WHICH HEIGHTS ARE ON THE MENU, which is the arithmetic above plus three
@@ -1163,6 +1186,9 @@ export function wireOutputs({
     // screen, prepared and moved to without their player being told.
     prepareSameHeightSwitch: (output, consumerId, direction, reason) =>
       parts.renditions.prepareSameHeightSwitch(output, consumerId, direction, reason),
+    // And on the machine: another speed setting of that size (torrent-tv/meta#178).
+    preparePresetSwitch: (output, consumerId, direction, reason) =>
+      parts.renditions.preparePresetSwitch(output, consumerId, direction, reason),
     sameHeightSwitchPending: (consumerId) => parts.renditions.sameHeightSwitchPending(consumerId),
     sameHeightSwitchDirection: (consumerId) => parts.renditions.sameHeightSwitchDirection(consumerId),
     cancelSameHeightSwitch: (consumerId, reason) => parts.renditions.cancelSameHeightSwitch(consumerId, reason),

package/services/torrent/PlaybackProjection.js

@@ -267,11 +267,18 @@ class RangeEntry {
 
 /** One output segment as the projection holds it. */
 class Segment {
-  constructor(output, index, from, to) {
+  constructor(output, index, from, to, reach = to) {
     this.output = output;
     this.index = index;
     this.from = from;
     this.to = to;
+    /**
+     * Up to which second the map's zones are read for it: its end, and for a
+     * piece that copies a stream the second its end falls in as well, as the
+     * encode plan reads it (`Timeline.inSegments`): the player asks a viewer
+     * standing at its end for this piece, and its bytes are fetched for them.
+     */
+    this.reach = reach;
     /** Whether a zone of the map overlaps it. */
     this.demanded = false;
     /** Whether the output has it made. */
@@ -304,13 +311,16 @@ class Segment {
 
 /** One output: its grid, how long its segments take to make and deliver, what is made, and its next input. */
 class OutputState {
-  constructor(outputKey, grid) {
+  constructor(outputKey, grid, runsPastEnd = false) {
     this.outputKey = outputKey;
     this.grid = grid;
+    this.runsPastEnd = runsPastEnd;
     /** @type {Segment[]} */
     this.segments = [];
     for (let index = 0; index + 1 < grid.length; index++) {
-      this.segments.push(new Segment(this, index, grid[index], grid[index + 1]));
+      const end = grid[index + 1];
+      this.segments.push(new Segment(this, index, grid[index], end,
+        runsPastEnd && index + 2 < grid.length ? Math.max(end, Math.floor(end) + 1) : end));
     }
     this.encodeSpeed = undefined;
     this.bytesPerSecond = undefined;
@@ -370,7 +380,7 @@ export class PlaybackProjection {
    * @param {object} params
    * @param {Array<{ from: number, to: number, priority: number, urgent?: boolean, behind?: boolean, deferred?: boolean,
    *   deadlineAt?: number }>} params.zones - The file's map zones, deadlines as instants.
-   * @param {Array<{ outputKey: string, grid: number[], encodeSpeed?: number, bytesPerSecond?: number | null,
+   * @param {Array<{ outputKey: string, grid: number[], runsPastEnd?: boolean, encodeSpeed?: number, bytesPerSecond?: number | null,
    *   linkMbps?: number | null, readyRevision: unknown, ready: () => Map<number, number>,
    *   target: number | null }>} params.outputs - Every output of the file somebody is watching, with
    *   what decides how long its segments take to make and deliver (`sourceDeadline`), what it has made
@@ -391,13 +401,13 @@ export class PlaybackProjection {
     for (const info of outputs) {
       seen.add(info.outputKey);
       let output = this.#outputs.get(info.outputKey);
-      if (output && output.grid !== info.grid) {
+      if (output && (output.grid !== info.grid || output.runsPastEnd !== Boolean(info.runsPastEnd))) {
         this.#dropOutput(output);
         output = undefined;
       }
       const fresh = !output;
       if (fresh) {
-        output = new OutputState(info.outputKey, info.grid);
+        output = new OutputState(info.outputKey, info.grid, Boolean(info.runsPastEnd));
         this.#outputs.set(info.outputKey, output);
       }
       // How long a segment of it takes to make and deliver.
@@ -426,7 +436,9 @@ export class PlaybackProjection {
         for (const segment of output.segments) if (this.#demand(segment, zones, ordered, nextBase, leadMoved)) reworked++;
       } else {
         for (const { from, to } of stretches) {
-          for (let index = segmentAt(output.grid, from); index < output.segments.length && output.segments[index].from < to; index++) {
+          // A piece reaching past its end is read for the stretch after it too.
+          for (let index = Math.max(0, segmentAt(output.grid, from) - (output.runsPastEnd ? 1 : 0));
+            index < output.segments.length && output.segments[index].from < to; index++) {
             if (this.#demand(output.segments[index], zones, ordered, nextBase, false)) reworked++;
           }
         }
@@ -542,7 +554,7 @@ export class PlaybackProjection {
   #demand(segment, zones, ordered, base, leadMoved) {
     // The zones it overlaps, folded as they are met.
     let owner = null, ownerDeadline = Infinity, priority = 0, urgent = false, behind = true, deferred = true;
-    const { from, to } = segment;
+    const { from, reach: to } = segment;
     for (let at = ordered ? firstEndingAfter(zones, from) : 0; at < zones.length; at += 1) {
       const zone = zones[at];
       if (ordered && !(zone.from < to)) break;
@@ -592,8 +604,8 @@ export class PlaybackProjection {
     let owner = null, ownerDeadline = Infinity;
     for (let at = this.#ordered ? firstEndingAfter(zones, segment.from) : 0; at < zones.length; at += 1) {
       const zone = zones[at];
-      if (this.#ordered && !(zone.from < segment.to)) break;
-      if (!(zone.priority > 0) || !(zone.from < segment.to && zone.to > segment.from)) continue;
+      if (this.#ordered && !(zone.from < segment.reach)) break;
+      if (!(zone.priority > 0) || !(zone.from < segment.reach && zone.to > segment.from)) continue;
       const deadline = Number.isFinite(zone.deadlineAt) ? zone.deadlineAt + Math.max(0, segment.from - zone.from) * 1000 : Infinity;
       if (owner === null || deadline < ownerDeadline) { owner = zone; ownerDeadline = deadline; }
     }