@torrent-tv/proxy 2.97.31 → 2.98.0

package/bin/cli.js

@@ -88,6 +88,7 @@ program
   .option("--no-transcode-audio", "Disable optional HLS AAC audio transcoding")
   .option("--no-port-mapping", "Disable automatic UPnP/NAT-PMP port mapping")
   .option("--delivery-sink", "Serve /api/delivery-sink, a torrent-free byte stream for delivery testing")
+  .option("--pin-preset <name>", "Encode every software picture at this libx264 preset only, for runs that must be compared at one quality (off by default)")
   .option("--profile-start <seconds>", "Profile the main thread's CPU for this many seconds from the first source opened, written beside the state (off by default)")
   .option(
     "--send-chunk-bytes <bytes>",
@@ -394,6 +395,7 @@ try {
     logFile: options.logFile ?? "",
     deliverySink: options.deliverySink === true,
     profileStartSeconds: Number(options.profileStart) || 0,
+    pinnedPreset: typeof options.pinPreset === "string" && options.pinPreset.trim() ? options.pinPreset.trim() : null,
     // Late-bound the same way `webRtcManager` is below: the torrent pool is
     // built inside `startProxyServer`, before `dataChannelHandler` — the
     // thing that actually owns a channel to push down — exists.

package/package.json

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

package/server.js

@@ -127,6 +127,9 @@ export async function startProxyServer({
   deliverySink = false,
   // Seconds of main-thread CPU profile from the first source opened; 0 is off.
   profileStartSeconds = 0,
+  // The one software preset every picture is encoded at, for runs compared at
+  // one quality; null leaves the choice to the machine.
+  pinnedPreset = null,
   // What viewers' connections carry beyond the film, per byte of film; the
   // transport counts it and is built after this server, so it is late-bound.
   serviceShare = () => null,
@@ -798,6 +801,7 @@ export async function startProxyServer({
   });
   let sourcePreparation;
   const outputParts = wireOutputs({
+    pinnedPreset,
     indexMemory,
     serviceShare,
     readMetadataActivity: () => containerOrchestrator.activity(),

package/services/encode/Renditions.js

@@ -1358,8 +1358,23 @@ export class Renditions {
     if (!base) {
       return null;
     }
-    if (!this.#host.qualityOffer.offeredHeightsFor(base).includes(height)) {
-      return null;
+    const offered = this.#host.qualityOffer.offeredHeightsFor(base);
+    if (!offered.includes(height)) {
+      if (!this.#host.outputs.splicableHeights(base).includes(height)) {
+        return null;
+      }
+      // A STEP THE MASTER LISTS AND THE OFFER NO LONGER HOLDS. The offer moves
+      // with what the machine measures, and a page preparing a step it was
+      // asked for can arrive after the ask was withdrawn: field r28, 360p
+      // asked at 21:40:44.308, the offer down to 400p at 21:40:46.143, the
+      // warm-up at 46.170 answered "no such variant" (torrent-tv/meta#178).
+      // The step exists; it is not available now, and the page keeps what it
+      // plays and follows the next ask.
+      this.#host.logger.info(`transcode ${base.id} warming ${height}p for ${consumerId}: not offered now (offering ${offered.map(one => `${one}p`).join(" ") || "nothing"})`);
+      const error = new Error(`${height}p is not offered now.`);
+      error.code = OUTPUT_UNAVAILABLE;
+      error.details = { reason: `${height}p is not offered on this machine now`, figures: { height, offeredHeights: offered } };
+      throw error;
     }
     const index = this.#host.outputTimes.segmentIndexForTime(base, positionSeconds);
     const variant = await this.resolveVariantSession(baseSessionId, height, index, consumerId);

package/services/encode/hwaccel.js

@@ -1715,7 +1715,8 @@ export function buildResolutionLadder(ceilingWidth, ceilingHeight) {
  * @param {{ width: number, height: number }} ceiling
  * @param {number} outputFps
  * @param {{ decodeModel?: object | null, source?: { megapixelsPerSecond: number, megabitsPerSecond: number } | null, requiredSpeed?: number | null }} [cost]
- * @returns {{ width: number, height: number, preset: string, ladder: Array<{ width: number, height: number }>, rungIndex: number } | null}
+ * @returns {{ width: number, height: number, preset: string, ladder: Array<{ width: number, height: number }>, rungIndex: number, bar: number } | null}
+ *   `bar` is the speed the choice had to clear.
  */
 export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost = {}) {
   if (!Array.isArray(benchmark) || benchmark.length === 0) {
@@ -1750,7 +1751,7 @@ export function chooseSoftwareEncodeSettings(benchmark, ceiling, outputFps, cost
   }
   const chosen = ladder[chosenIndex];
   const preset = pickSoftwarePreset(benchmark, chosen.width * chosen.height * fps, cost, chosen);
-  return { width: chosen.width, height: chosen.height, preset, ladder, rungIndex: chosenIndex };
+  return { width: chosen.width, height: chosen.height, preset, ladder, rungIndex: chosenIndex, bar };
 }
 
 /**

package/services/encode/quality/EncodeCost.js

@@ -1103,7 +1103,8 @@ export class EncodeCost {
     sourceHeight,
     outputFps,
     source = null,
-    requiredSpeed = null
+    requiredSpeed = null,
+    observedDecodeCostSec = null
   }) {
     if (!transcodeVideo || this.#host().encoderKind !== "software" || !this.#host().benchmark) {
       return null;
@@ -1113,26 +1114,44 @@ export class EncodeCost {
       return null;
     }
     const concurrentCostSec = this.#committedMachineCostSec();
+    // THE FILE'S OWN DECODE COST, where its encoder has already been read: the
+    // 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;
+    /** Every size and preset the choice priced, with the speed it was priced at. */
+    const considered = [];
     const speedForPreset = (benchmark, frame, outputPixelsPerSec) => {
-      if (concurrentCostSec === null) {
-        return null;
-      }
-      return this.#speedOnThisMachine({
+      const speed = concurrentCostSec === null ? null : this.#speedOnThisMachine({
         benchmark,
         source,
         width: frame.width,
         height: frame.height,
         fps: outputPixelsPerSec / (frame.width * frame.height),
-        observedDecodeCostSec: null,
+        observedDecodeCostSec: decodeCostSec,
         concurrentCostSec
       });
+      considered.push({ preset: benchmark[0]?.preset, width: frame.width, height: frame.height, speed });
+      return speed;
     };
-    return chooseSoftwareEncodeSettings(
+    const choice = chooseSoftwareEncodeSettings(
       this.#host().benchmark,
       { width: ceiling.w, height: ceiling.h },
       outputFps,
-      { decodeModel: this.#host().decodeModel, source, requiredSpeed, speedForPreset }
+      { decodeModel: this.#host().decodeModel, source, requiredSpeed, speedForPreset, observedDecodeCostSec: decodeCostSec }
     );
+    // WHAT THE CHOICE WAS MADE FROM, said once per choice: three runs of one
+    // file on one host opened at three presets and nothing said why (r25, r26,
+    // 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(", ");
+      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`}; ` +
+        `machine ${availability?.known ? `${Math.round(availability.share * 100)}% to spare` : "share unknown"}; ` +
+        `committed work ${concurrentCostSec === null ? "unmeasured" : `${concurrentCostSec.toFixed(3)} s per second`}`);
+    }
+    return choice;
   }
 }
 

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

@@ -144,7 +144,8 @@ export function decideOutputFormat({
         sourceHeight: source.height,
         outputFps: fps,
         source: source.decode,
-        requiredSpeed: cost.requiredSpeed
+        requiredSpeed: cost.requiredSpeed,
+        observedDecodeCostSec: cost.observedDecodeCostSec ?? null
       });
   const width = budget?.width ?? ceiling?.w ?? 0;
   const height = budget?.height ?? ceiling?.h ?? 0;

package/services/server/wire-outputs.js

@@ -189,6 +189,9 @@ export function wireOutputs({
     keyframeTables = new KeyframeTables(),
     videoEncoder = null,
     softwarePresetBenchmark = null,
+    // A software preset every picture is encoded at, for runs compared at one
+    // quality (`--pin-preset`); null leaves the choice to the machine.
+    pinnedPreset = null,
     // What every encoder this host may use was qualified and measured to do at
     // startup, by kind (`encode/calibration.js`). Takes the place of the one
     // array above, which a test may still hand in on its own.
@@ -771,8 +774,26 @@ export function wireOutputs({
   // Null where nothing was measured, and then nothing is re-encoded here.
   parts.calibration = calibration ?? null;
   const givenModes = Array.isArray(softwarePresetBenchmark) ? softwarePresetBenchmark : null;
+  // ONE PRESET FOR RUNS COMPARED AT ONE QUALITY. Three runs of one film on one
+  // host opened at `faster`, `veryfast` and `fast`, so no change could be
+  // compared at the same picture (r25, r26, r28, torrent-tv/meta#178). Pinned
+  // here, every decision that prices or chooses a software mode — the choice,
+  // the offer, the machine's admission and the command — sees the one mode,
+  // measured as calibrated. A preset calibration did not qualify is not
+  // pinned: the machine's own list stands, and the log says so.
+  let pinWarned = false;
+  const pinned = (modes) => {
+    if (!pinnedPreset || !Array.isArray(modes) || parts.encoders.current?.kind !== "software") return modes;
+    const kept = modes.filter(mode => mode.preset === pinnedPreset);
+    if (kept.length > 0) return kept;
+    if (!pinWarned) {
+      pinWarned = true;
+      logger.warn(`encode: --pin-preset ${pinnedPreset} names no calibrated mode (${modes.map(mode => mode.preset).join(", ")}); not pinned`);
+    }
+    return modes;
+  };
   Object.defineProperty(parts, "softwarePresetBenchmark", {
-    get: () => (parts.calibration
+    get: () => pinned(parts.calibration
       ? parts.calibration.modesFor(parts.encoders.current?.kind)
       : givenModes),
     enumerable: true