@torrent-tv/proxy 2.87.11 → 2.87.12

package/services/encode/EncodeAdmission.js

@@ -69,6 +69,7 @@ import { correctForAvailability } from "./available-share.js";
  * @property {() => Set<string>} [watchedAddresses] - Every output a present
  *   viewer is watching that still has something left to make.
  * @property {(address: string) => OutputLoad | null} loadOf
+ * @property {(spec: object, file: object) => OutputLoad | null} [loadForCandidate]
  * @property {() => ({ share: number, known: boolean } | null)} availability
  */
 
@@ -189,7 +190,50 @@ export class EncodeAdmission {
     if (this.#heldWithoutRun().has(address)) {
       return { admitted: true, reason: "it already holds a place for another viewer", speedX: null };
     }
-    const load = this.#host.loadOf(address);
+    return this.#assessCandidate(address, this.#host.loadOf(address));
+  }
+
+  /**
+   * Whether a not-yet-opened format can take a place on the whole machine.
+   * The output choice calls this for each candidate rung; the final claim uses
+   * `admitsWatching` with the same arithmetic after registering the output.
+   *
+   * @param {object} spec
+   * @param {object} file
+   * @returns {{ admitted: boolean, reason: string, speedX: number | null }}
+   */
+  previewCandidate(spec, file) {
+    const address = typeof spec?.toKey === "function" ? spec.toKey() : "";
+    if (!address) {
+      return { admitted: false, reason: "the output has no address", speedX: null };
+    }
+    if ((this.#host.liveRunsByAddress().get(address) ?? 0) > 0) {
+      return { admitted: true, reason: "an encoder already runs there", speedX: null };
+    }
+    if (this.#heldWithoutRun().has(address)) {
+      return { admitted: true, reason: "it already holds a place for another viewer", speedX: null };
+    }
+    const load = this.#host.loadForCandidate?.(spec, file) ?? null;
+    return this.#assessCandidate(address, load);
+  }
+
+  /**
+   * Projected production rate for outputs currently holding machine capacity.
+   * A live encoder reading takes precedence; this measured-cost projection
+   * supplies the playback trajectory before its first run sample arrives.
+   *
+   * @returns {number | null}
+   */
+  projectedSpeedX() {
+    const occupied = this.#occupied(null);
+    if (occupied.unpriced.length > 0) {
+      return null;
+    }
+    const speedX = this.#speedAt(occupied.costSec);
+    return Number.isFinite(speedX) && speedX > 0 ? speedX : null;
+  }
+
+  #assessCandidate(address, load) {
     if (!load || load.costSec === null) {
       return { admitted: false, reason: "the output has no measured encoding cost", speedX: null };
     }

package/services/encode/OutputOpening.js

@@ -45,7 +45,7 @@ export class OutputOpening {
   #host;
 
   /**
-   * @param {object} host - `logger`, `probeMediaInfo`, `probeKeyframeTimes`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
+   * @param {object} host - `logger`, `probeMediaInfo`, `probeKeyframeTimes`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `admission`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
    * @param {SegmentOutputFiles} host.segmentOutputFiles - The storage
    *   operations needed while selecting or opening an output.
    */
@@ -573,6 +573,9 @@ export class OutputOpening {
         requiredSpeed: this.#host.hostLoad.requiredSpeedFor(sourceKey, fileIndex)
       },
       chooseBudget: (params) => this.#host.encodeCost.chooseEncodeBudget(params),
+      machineAdmission: this.#host.admission
+        ? (candidate) => this.#host.admission.previewCandidate(candidate, file)
+        : null,
       tonemap: applyTonemap,
       capKbps,
       limitsFor: (frame) => this.#host.limitsFor(frame),

package/services/encode/quality/EncodeCost.js

@@ -329,6 +329,37 @@ export class EncodeCost {
     if (!session) {
       return null;
     }
+    return this.#loadOfSession(session);
+  }
+
+  /**
+   * What a not-yet-opened output would cost, priced by the same readings and
+   * rules as an output already in the catalogue. This lets the machine-wide
+   * admission answer before the format is committed, so AUTO can select a
+   * lower rung that the whole host can sustain.
+   *
+   * @param {object} spec
+   * @param {object} file
+   * @returns {{ costSec: number | null, fileKey: string, fileCostSec: number } | null}
+   */
+  loadForCandidate(spec, file) {
+    if (!spec || !file) {
+      return null;
+    }
+    const encode = spec.video?.encode ?? null;
+    const candidate = {
+      spec,
+      file,
+      output: {
+        encodeWidth: Number(encode?.width) || 0,
+        encodeHeight: Number(encode?.height) || 0,
+        outputFps: Number(encode?.fps) || TRANSCODE_FPS
+      }
+    };
+    return this.#loadOfSession(candidate);
+  }
+
+  #loadOfSession(session) {
     const fileKey = session.file?.key ?? "";
     const fileCost = Number(this.#torrentCostSecFor(session));
     const fileCostSec = Number.isFinite(fileCost) && fileCost > 0 ? fileCost : 0;

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

@@ -51,6 +51,8 @@ import { linkAnswerFigures, linkCouldCarry, loadOf, videoLoadOfSpec } from "./li
  * @param {unknown} params.benchmark - The startup measurement of the software encoder, or null.
  * @param {{ decodeModel: object | null, observedDecodeCostSec: number | null, requiredSpeed: number | null }} params.cost
  * @param {(params: object) => object | null} params.chooseBudget - The realtime budget's ladder choice.
+ * @param {(spec: OutputSpec) => { admitted: boolean, reason: string, speedX: number | null }} [params.machineAdmission] -
+ *   The proxy's machine-wide capacity decision for a candidate output.
  * @param {boolean} params.tonemap
  * @param {number | null} [params.capKbps] - A nominal limit asked for outright;
  *   above the size's own it is refused (`softwareRateControlFor`).
@@ -86,7 +88,8 @@ export function decideOutputFormat({
   limitsFor = (frame) => [nominalKbpsFor(frame)],
   audioLoad = null,
   specWith,
-  serving
+  serving,
+  machineAdmission = null
 }) {
   const judge = (spec) => linkCouldCarry(
     serving.linkMbps,
@@ -170,6 +173,22 @@ export function decideOutputFormat({
     : 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) {
+      return budget;
+    }
+    const rungIndex = budget.ladder?.findIndex((rung) =>
+      rung.width === encode.width && rung.height === encode.height
+    ) ?? budget.rungIndex;
+    return {
+      ...budget,
+      width: encode.width,
+      height: encode.height,
+      preset: encode.preset,
+      rungIndex: rungIndex >= 0 ? rungIndex : budget.rungIndex
+    };
+  };
   // Every format at one size this viewer could be given, highest limit first.
   // A hardware encoder is given no limit, so it has exactly one.
   const formatsAt = (w, h) => {
@@ -220,12 +239,28 @@ export function decideOutputFormat({
     }
   }
 
-  let anySizeHeld = machineCan(width, height);
-  if (anySizeHeld) {
+  let anySizeHeld = false;
+  let machineRefusal = null;
+  const admittedByMachine = (spec) => {
+    if (!machineCan(spec.video?.encode?.width ?? 0, spec.video?.encode?.height ?? 0)) {
+      return false;
+    }
+    const answer = typeof machineAdmission === "function" ? machineAdmission(spec) : null;
+    if (answer?.admitted === false) {
+      machineRefusal ??= answer;
+      return false;
+    }
+    return true;
+  };
+  if (machineCan(width, height)) {
     for (const spec of wantedFormats) {
+      if (!admittedByMachine(spec)) {
+        continue;
+      }
+      anySizeHeld = true;
       const answer = judge(spec);
       if (answer.admitted) {
-        return given(spec, answer, { budget, wantedKey });
+        return given(spec, answer, { budget: budgetFor(spec), wantedKey });
       }
     }
   }
@@ -234,11 +269,14 @@ export function decideOutputFormat({
       if (!machineCan(rung.width, rung.height)) {
         continue;
       }
-      anySizeHeld = true;
       for (const spec of formatsAt(rung.width, rung.height)) {
+        if (!admittedByMachine(spec)) {
+          continue;
+        }
+        anySizeHeld = true;
         const answer = judge(spec);
         if (answer.admitted) {
-          return given(spec, answer, { wantedKey });
+          return given(spec, answer, { budget: budgetFor(spec), wantedKey });
         }
       }
     }
@@ -247,10 +285,21 @@ export function decideOutputFormat({
     // Not the viewer's link: this machine. Said apart, because the answer to
     // it is another proxy, found before anything plays.
     return {
-      ...refused(wantedSpec, null, `this machine has not shown it can re-encode this picture at ${width}x${height}@${fps} or any size below it`, { budget, wantedKey }),
+      ...refused(
+        wantedSpec,
+        null,
+        machineRefusal?.reason ?? `this machine has not shown it can re-encode this picture at ${width}x${height}@${fps} or any size below it`,
+        { budget, wantedKey }
+      ),
       unavailable: {
-        reason: `this machine has not shown it can re-encode this picture at ${width}x${height}@${fps} or any size below it`,
-        figures: { width, height, fps, encoder: encoder.name },
+        reason: machineRefusal?.reason ?? `this machine has not shown it can re-encode this picture at ${width}x${height}@${fps} or any size below it`,
+        figures: {
+          width,
+          height,
+          fps,
+          encoder: encoder.name,
+          ...(Number.isFinite(machineRefusal?.speedX) ? { speedX: Number(machineRefusal.speedX.toFixed(3)) } : {})
+        },
         bound: "machine"
       }
     };