@torrent-tv/proxy 2.98.11 → 2.98.13

package/package.json

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

package/services/encode/EncodePlan.js

@@ -362,6 +362,26 @@ export function planEncoders({
   const decided = new Map();
   const room = Math.max(0, maxRuns - live.length);
   const refetchPerSegment = segmentSeconds * refetchSecPerFilmSecond;
+  // WHAT "NEVER" IS, ONE FIGURE FOR EVERY ARRANGEMENT THIS PASS COMPARES: later
+  // than any encoder here can reach the last wanted number — the film's length,
+  // a start and a stop, the whole wanted stretch at the slowest rate any
+  // arrangement can run at, and every piece fetched again. Capped at the film's
+  // length instead, a slow encoder's arrival scored as never; and worked out
+  // from each arrangement's own encoders, the arrangement without an encoder
+  // had a smaller never than the one with it. Either way an encoder making the
+  // film behind the viewer at 0.57x scored no better than none, and the plan
+  // stopped it before its first piece, then started it again when the speed
+  // read 1.9x — thirteen times in three minutes on Home Assistant, each start
+  // copying 108-122 MB of input (r37, torrent-tv/meta#178).
+  const neverSec = (() => {
+    const first = Math.min(...wanted.map((span) => span.from));
+    const last = Math.max(...wanted.map((span) => span.to));
+    const film = (last + 1) * segmentSeconds;
+    const slowest = rate / contentionPenaltyFor(Math.max(maxRuns, live.length));
+    if (!(slowest > 0) || !Number.isFinite(film)) return film;
+    return film + firstByteWaitSec + killCostSec + (last - first + 2) / slowest +
+      (last - first + 1) * refetchPerSegment + segmentSeconds;
+  })();
 
   let arrangements = [{ fill: [], used: new Set(), fresh: 0 }];
   for (let index = 0; index < positions.length; index += 1) {
@@ -441,7 +461,7 @@ export function planEncoders({
           : (piece) => finishesItsPieceIn(run, piece)
       });
     }
-    const scored = latenessOf(priced(encoders), coverage, wanted, untilNeeded, rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+    const scored = latenessOf(priced(encoders), coverage, wanted, untilNeeded, rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
     if (bestScore === null || cheaperThan(scored, bestScore)) {
       bestScore = scored;
       best = arrangement;
@@ -492,7 +512,7 @@ export function planEncoders({
   const scoreOf = (override) => {
     const encoders = encodersOf(override);
     return latenessOf(encoders, coverage, wanted, untilNeeded,
-      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
   };
   for (const run of live) {
     if (placement.has(run)) {
@@ -519,7 +539,7 @@ export function planEncoders({
     const kept = encodersOf(new Map());
     const without = encodersOf(new Map([[run, null]]));
     const scoreOf_ = (encoders) => latenessOf(encoders, coverage, wanted, untilNeeded,
-      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds);
+      rate / contentionPenaltyFor(Math.max(0, encoders.length - 1)), refetchPerSegment, segmentSeconds, neverSec);
     return cheaperThan(scoreOf_(kept), scoreOf_(without));
   };
 
@@ -586,7 +606,7 @@ export function planEncoders({
         continue;
       }
       const without = latenessOf(encodersOf(new Map([[run, null]])), coverage, wanted, untilNeeded,
-        rate / contentionPenaltyFor(Math.max(0, live.length - 2)), refetchPerSegment, segmentSeconds);
+        rate / contentionPenaltyFor(Math.max(0, live.length - 2)), refetchPerSegment, segmentSeconds, neverSec);
       if (cheapestScore === null || cheaperThan(without, cheapestScore)) {
         cheapestScore = without;
         cheapest = run;
@@ -751,13 +771,14 @@ function ranksOf(wanted, first, last) {
   return rankAt;
 }
 
-function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPerSegment, segmentSeconds) {
+function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPerSegment, segmentSeconds, neverSec = null) {
   const first = Math.min(...wanted.map((span) => span.from));
   const last = Math.max(...wanted.map((span) => span.to));
-  // What a number nobody reaches at all counts as. The film's own length is the
-  // honest bound — nothing can be later than never — and a finite figure is what
-  // lets two hopeless arrangements still be told apart by the rest of the sum.
-  const never = (last + 1) * segmentSeconds;
+  // What a number nobody reaches at all counts as: one figure for every
+  // arrangement the plan compares, later than any arrival (`neverSec` in
+  // `planEncoders`), and finite, so two hopeless arrangements are still told
+  // apart by the rest of the sum. Without it, the film's own length.
+  const never = Number.isFinite(neverSec) ? neverSec : (last + 1) * segmentSeconds;
 
   // WHICH SIDE OF THE VIEWERS a piece is on. The map states it; nothing here
   // works it out from positions, and nothing here knows where a viewer stands.
@@ -876,7 +897,7 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
     // gives. It is a definition rather than a guard: it also makes the score
     // total on a host whose startup measured nothing at all, where every arrival
     // is beyond reckoning and every arrangement is therefore equally hopeless.
-    const when = byWhom === null ? never : Math.min(soonest, never);
+    const when = byWhom === null || !Number.isFinite(soonest) ? never : soonest;
     const rank = rankAt(index);
     doneAt.set(rank, Math.max(doneAt.get(rank) ?? 0, when));
     const deadline = untilNeeded(index);

package/services/encode/EncodeRuns.js

@@ -13,6 +13,7 @@ import { contentionPenalty } from "./contention.js";
 import { LOOKAHEAD_PAUSE_SECONDS } from "./CushionReport.js";
 import { SpeedReadings } from "./SpeedReadings.js";
 import { nextInputAtFirstPiece } from "./next-input.js";
+import { runOpenOf } from "./run-open.js";
 import { ENCODE_RUN_STATE, liveRunsOf, runStateOf, wireState } from "./encode-run-state.js";
 import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun, endOfRun } from "./EncodeRun.js";
@@ -1330,11 +1331,14 @@ export class EncodeRuns {
     const grid = session.timeline?.published ?? session.timeline?.boundaries;
     const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
     const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
-    if (!Number.isFinite(ended.firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return;
     // FFmpeg's reads may have waited for the stretch being copied; that wait
-    // is the copy's, and the stretch is sized from the open (torrent-tv/meta#178).
-    const waitedMs = Number.isFinite(ended.firstNamedWallMs) ? run.originalInput?.waitedBefore?.(ended.firstNamedWallMs) ?? 0 : 0;
-    const openSeconds = Math.max(0, (ended.firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed);
+    // is the copy's, and the stretch is sized from the open (`run-open.js`).
+    const open = runOpenOf({
+      firstNamedMs: ended.firstNamedMs, firstNamedWallMs: ended.firstNamedWallMs, startedAt: run.startedAt,
+      waitedBefore: run.originalInput?.waitedBefore, pieceSeconds, speed
+    });
+    if (!open) return;
+    const { openSeconds, waitedMs } = open;
     this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +
       `${openSeconds.toFixed(2)}s (first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film at ${speed.toFixed(2)}x` +

package/services/encode/run-open.js

@@ -0,0 +1,29 @@
+/**
+ * @file How long a run took to open its original input (torrent-tv/meta#178).
+ *
+ * Measured from the run's spawn to the name of its first closed piece, less
+ * what encoding that piece costs at the run's speed, and less the time
+ * FFmpeg's reads waited for the stretch being copied: that wait is the copy's,
+ * and the stretch is sized from the open. The input states those waits on the
+ * wall clock, so they are taken up to the wall-clock moment the first piece
+ * was named — the run's start plus its time to that name, not that time alone,
+ * which as a moment lay before every wait and counted none of them.
+ */
+
+/**
+ * @param {object} params
+ * @param {number | null} params.firstNamedMs - Spawn to the first piece's name, pauses left out.
+ * @param {number | null} params.firstNamedWallMs - The same on the wall clock, pauses included.
+ * @param {number} params.startedAt - The run's spawn on the wall clock, ms.
+ * @param {((until: number) => number) | null | undefined} params.waitedBefore - The input's wall-clock waits for its copy before `until`, ms.
+ * @param {number} params.pieceSeconds - The first piece's film.
+ * @param {number} params.speed - Film seconds per second; 0 when not known.
+ * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is unknown.
+ */
+export function runOpenOf({ firstNamedMs, firstNamedWallMs, startedAt, waitedBefore, pieceSeconds, speed }) {
+  if (!Number.isFinite(firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return null;
+  const waitedMs = Number.isFinite(firstNamedWallMs) && startedAt > 0 && typeof waitedBefore === "function"
+    ? waitedBefore(startedAt + firstNamedWallMs)
+    : 0;
+  return { waitedMs, openSeconds: Math.max(0, (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed) };
+}