@torrent-tv/proxy 2.98.9 → 2.98.11

package/package.json

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

package/services/encode/EncodeInputs.js

@@ -28,6 +28,8 @@ export class EncodeInputs {
   /** Whether an output's last resolved input was its original file. @type {WeakMap<object, boolean>} */
   #original = new WeakMap();
   #revision = 0;
+  /** Output → how long its last input took to be ready, ms. @type {WeakMap<object, number>} */
+  #preparedIn = new WeakMap();
   #memoryRevision = 0;
   #held = 0;
   #allowed = 0;
@@ -270,6 +272,18 @@ export class EncodeInputs {
    * @param {{ sourceKey: string, ranges: Array<{ fileIndex: number, start: number, end: number }> } | null} [arrived] -
    *   The bytes that arrived, inclusive, when the event names them.
    */
+  /**
+   * How long this output's last input took from being asked for to being
+   * ready, in milliseconds, or null before one was: the time a run gives the
+   * input after it to be prepared in (`EncodeRuns`).
+   *
+   * @param {object} output
+   * @returns {number | null}
+   */
+  preparationMsOf(output) {
+    return this.#preparedIn.get(output) ?? null;
+  }
+
   bytesChanged(arrived = null) {
     this.#revision++;
     for (const request of this.#requests.values()) {
@@ -376,6 +390,7 @@ export class EncodeInputs {
       // is commanded over its prefix.
       if (result.kind === "result" && result.to > request.to) result.to = Math.max(request.from, request.to);
       request.result = result;
+      if (result.kind === "result") this.#preparedIn.set(request.output, this.#now() - request.timing.askedAt);
       this.#note(request, result.kind === "result" ? `ready #${result.from}..#${result.to}, ${result.bytes ?? "?"} bytes` +
         (Number.isFinite(result.copyMs) ? (result.deferredBytes > 0
           ? `, opening part copied in ${result.copyMs}ms, ${result.deferredBytes} bytes of the stretch copied while the run opens`

package/services/encode/EncodeRuns.js

@@ -12,6 +12,7 @@ import { spawn } from "node:child_process";
 import { contentionPenalty } from "./contention.js";
 import { LOOKAHEAD_PAUSE_SECONDS } from "./CushionReport.js";
 import { SpeedReadings } from "./SpeedReadings.js";
+import { nextInputAtFirstPiece } from "./next-input.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";
@@ -497,15 +498,14 @@ export class EncodeRuns {
   }
 
   /**
-   * The speed readings of this output's runs measured after `after`, oldest
-   * first, within the forecast's horizon.
+   * The speed readings of this output's runs within the forecast's horizon,
+   * in the order they were taken.
    *
    * @param {object} output
-   * @param {number} [after] - The time of the last reading the asker has.
    * @returns {Array<{ speed: number, at: number }>}
    */
-  speedReadingsOf(output, after) {
-    return this.#speedReadings.after(output, after);
+  speedReadingsOf(output) {
+    return this.#speedReadings.windowOf(output);
   }
 
   /**
@@ -1097,6 +1097,8 @@ export class EncodeRuns {
     // killed mid-piece leaving a partial file — is not a correctness problem
     // either, because the store serves a segment only once its closure is
     // proven, and it is cleared up when the run ends.
+    // Told when this run closes its first piece; see the next stretch below.
+    let atFirstPiece = null;
     const run = new EncodeRun({
       address: session.outputKey ?? session.id,
       encoder: this.#host.videoEncoder,
@@ -1130,7 +1132,12 @@ export class EncodeRuns {
       onProgress: (report) => this.#noteRunProgress(session, run, report),
       // A closed piece moves this encoder forward, perhaps out of the band that
       // led; who has the processor is decided again at once.
-      onProduced: () => this.#host.encodeOrchestrator?.shareTheMachine?.(),
+      onProduced: () => {
+        this.#host.encodeOrchestrator?.shareTheMachine?.();
+        const told = atFirstPiece;
+        atFirstPiece = null;
+        told?.();
+      },
       indexOfName: (name) => session.segmentFormat.segmentIndexFromName(
         session.segmentFormat.servedNameOf?.(name) ?? name),
       // Why this encoder exists, recorded with its argument list. It used to be
@@ -1232,12 +1239,24 @@ export class EncodeRuns {
       // It waits for this run's own stretch to be copied: that copy goes on
       // while the run opens and FFmpeg's reads wait for it, and a second copy
       // beside it on the same thread would slow it (torrent-tv/meta#178).
+      //
+      // And for this run's first piece when the rest of the run leaves the
+      // time to prepare it in (`next-input.js`).
       if (inputEnd < mayReach) {
         const askNext = () => {
           if (this.isLive(session) && run.isAlive) this.#host.encodeInputs?.take(session, inputEnd + 1, mayReach);
         };
-        if (admittedInput.whole) void admittedInput.whole.then(whole => { if (whole) askNext(); });
-        else askNext();
+        const preparedInMs = this.#host.encodeInputs?.preparationMsOf?.(session) ?? null;
+        const speed = Number(this.#host.encodeCost?.speedForOutput?.(session.outputKey));
+        const timeline = session.timeline;
+        const restSeconds = Number(timeline?.publishedStartOf?.(inputEnd + 1)) - Number(timeline?.publishedStartOf?.(safeIndex + 1));
+        const atOnce = !nextInputAtFirstPiece({ preparedInMs, speed, restSeconds });
+        let copied = false, produced = atOnce;
+        const askWhenBoth = () => { if (copied && produced) askNext(); };
+        if (!atOnce) atFirstPiece = () => { produced = true; askWhenBoth(); };
+        const whenCopied = () => { copied = true; askWhenBoth(); };
+        if (admittedInput.whole) void admittedInput.whole.then(whole => { if (whole) whenCopied(); });
+        else whenCopied();
       }
     } else if (admittedInput) {
       run.admittedInputKeys = new Map([[safeIndex, inputKey]]);

package/services/encode/SpeedReadings.js

@@ -2,8 +2,11 @@
  * @file The speed readings of each output's runs, in the order the runs
  * measured them, over the start forecast's horizon (torrent-tv/meta#178).
  *
- * A run announces a reading at each closed piece; whoever forecasts takes every
- * reading after the last one it has. The forecast used to take only the newest
+ * A run announces a reading at each closed piece; the forecast summarizes the
+ * whole window on each poll. Two runs of one output can announce out of order —
+ * each reading carries the time of its own run's last progress report — so the
+ * window is kept in the order the readings were TAKEN, and two taken in the
+ * same millisecond are two readings. The forecast used to take only the newest
  * reading of a run alive when it asked: on a cold start on Home Assistant the
  * runs were three pieces long and ended between its polls, and of the readings
  * 0.78, 1.80, 2.25, 2.84 and 2.69x it got 0.78 and 2.69x, and held the picture
@@ -28,18 +31,19 @@ export class SpeedReadings {
     if (!output || !(reading?.speed > 0) || !Number.isFinite(reading.at)) return;
     let readings = this.#byOutput.get(output);
     if (!readings) this.#byOutput.set(output, readings = []);
-    readings.push({ speed: reading.speed, at: reading.at });
-    const cutoff = reading.at - this.#keepMs;
+    let place = readings.length;
+    while (place > 0 && readings[place - 1].at > reading.at) place -= 1;
+    readings.splice(place, 0, { speed: reading.speed, at: reading.at });
+    const cutoff = readings.at(-1).at - this.#keepMs;
     // As the forecast's own trend keeps them: the newest one before the horizon stays.
     while (readings.length > 1 && readings[1].at <= cutoff) readings.shift();
   }
 
   /**
    * @param {object} output
-   * @param {number} [after] - The time of the last reading the asker has.
-   * @returns {Array<{ speed: number, at: number }>} Oldest first.
+   * @returns {Array<{ speed: number, at: number }>} The window, in the order the readings were taken.
    */
-  after(output, after = Number.NEGATIVE_INFINITY) {
-    return (this.#byOutput.get(output) ?? []).filter(reading => reading.at > after);
+  windowOf(output) {
+    return [...(this.#byOutput.get(output) ?? [])];
   }
 }

package/services/encode/next-input.js

@@ -0,0 +1,26 @@
+/**
+ * @file When a run asks for the input of the run after it (torrent-tv/meta#178).
+ *
+ * Asked as soon as the run's own stretch was copied, the next input was copied
+ * while the run opened: a background run on Home Assistant started with its
+ * 108.7 MB, the next 115.6 MB were copied at once, the proxy took 1.5-2 cores,
+ * and the share left to encoders fell from 65 % to 10-16 % before either had
+ * a piece (r37). Asked at the run's first piece, it still has the rest of the
+ * run to be ready in — unless preparing an input of this output was measured
+ * to take longer than that rest at this output's speed, or the run is one
+ * piece, whose first piece is its last.
+ */
+
+/**
+ * Whether the next input waits for this run's first piece.
+ *
+ * @param {object} params
+ * @param {number | null} params.preparedInMs - How long this output's last input took from being asked for to being ready.
+ * @param {number} params.speed - This output's processing speed, film seconds per second; 0 when not known.
+ * @param {number} params.restSeconds - The film this run makes after its first piece.
+ * @returns {boolean}
+ */
+export function nextInputAtFirstPiece({ preparedInMs, speed, restSeconds }) {
+  if (!Number.isFinite(preparedInMs) || !(speed > 0) || !(restSeconds > 0)) return false;
+  return preparedInMs < restSeconds / speed * 1000;
+}

package/services/server/ViewerRequests.js

@@ -604,7 +604,7 @@ export class ViewerRequests {
     const tracks = [];
     for (const output of outputs) {
       const trackProgress = output === session ? progress : this.#host.encodeRuns.progressOf(output);
-      const trackRates = this.#trackRateReadings(measurement, output, now);
+      const trackRates = this.#trackRateReadings(output, now);
       const trackName = output === session ? "video" : "audio";
       // The page states the offset its player applied to this track, and the
       // init it applied it to is the session's. Until both are known, the
@@ -691,12 +691,6 @@ export class ViewerRequests {
       });
     }
 
-    const activeTrackIds = new Set(tracks.map(({ id }) => id));
-    for (const id of measurement.tracks.keys()) {
-      if (!activeTrackIds.has(id)) {
-        measurement.tracks.delete(id);
-      }
-    }
     const bufferedAheadSeconds = Number(viewerReading?.bufferedAheadSec);
     const positionSeconds = Number.isFinite(viewerReading?.positionSeconds)
       ? viewerReading.positionSeconds
@@ -880,25 +874,23 @@ export class ViewerRequests {
     const id = typeof consumerId === "string" ? consumerId : "";
     let state = byViewer.get(id);
     if (!state) {
-      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), tracks: new Map(), sources: new Map() };
+      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), sources: new Map() };
       byViewer.set(id, state);
     }
     return state;
   }
 
-  #trackRateReadings(state, output, now) {
-    const id = output.outputKey;
-    let trend = state.tracks.get(id);
-    if (!trend) {
-      trend = new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds);
-      state.tracks.set(id, trend);
-    }
-    // Every reading since this trend's last, not the newest one at the poll:
-    // a run that ended between two polls took its readings with it.
-    for (const reading of this.#host.encodeSpeedReadingsOf?.(output, trend.lastAt) ?? []) {
-      if (reading.at <= now) trend.add(reading.at, reading.speed);
-    }
-    if (!trend.snapshot()) {
+  /**
+   * The encoder's rate for the forecast: the output's whole window of readings,
+   * summarized again on each poll. A run that ended between two polls took its
+   * readings with it when the forecast asked for the newest one alone; and two
+   * runs of one output can report out of order, so a summary kept and added to
+   * would drop the later-told, earlier-taken one (torrent-tv/meta#178).
+   */
+  #trackRateReadings(output, now) {
+    const readings = (this.#host.encodeSpeedReadingsOf?.(output) ?? []).filter(reading => reading.at <= now);
+    const summary = readings.length > 0 ? this.#host.playbackReadiness.rateSummaryOf(readings) : null;
+    if (!summary) {
       // ONLY UNTIL A PIECE IS MEASURED does the prediction stand for the
       // encoder, and it is not kept among the readings. Added on every poll
       // between runs, it put the machine's share of that moment — 1 % at a
@@ -911,7 +903,7 @@ export class ViewerRequests {
         return seed.snapshot();
       }
     }
-    return trend.snapshot();
+    return summary;
   }
 
   /**

package/services/server/wire-outputs.js

@@ -71,7 +71,7 @@ import { ViewerRequests } from "./ViewerRequests.js";
 import { OutputLifecycle } from "./OutputLifecycle.js";
 import { SegmentServing } from "./SegmentServing.js";
 import { audioStartSecondsFor } from "../viewer/audio-start.js";
-import { forecastRate, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
+import { forecastRate, rateSummaryOf, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
 import { audioRenditionName } from "../media/audio-inventory.js";
 import { Renditions } from "../encode/Renditions.js";
 import { CushionReport, LOOKAHEAD_PAUSE_SECONDS } from "../encode/CushionReport.js";
@@ -578,12 +578,12 @@ export function wireOutputs({
     get encodeRuns() { return parts.encodeRuns; },
     // When this viewer's playback can start and run to the end: the viewer
     // component's forecast, which models the viewer's browser.
-    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, RateTrend },
+    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend },
     // Whether the subtitle a viewer chose has been read where they stand — the
     // source preparation's answer, set on these parts by the assembly.
     subtitleReadyFor: (viewer) => parts.subtitleReadyFor?.(viewer) ?? true,
     sourceInputsFor: (output, index) => parts.sourceInputsFor?.(output, index),
-    encodeSpeedReadingsOf: (output, after) => parts.encodeRuns.speedReadingsOf(output, after),
+    encodeSpeedReadingsOf: (output) => parts.encodeRuns.speedReadingsOf(output),
     projectedEncodeSpeedOf: (output) => parts.encodeCost.projectedSpeedOf(output),
     // The speed the offer predicted for this output when it chose its mode: a
     // forecast with no measured piece yet stands on it rather than on the

package/services/viewer/playback-readiness.js

@@ -58,6 +58,22 @@ export function forecastRate(readings, now = Date.now(), horizonSeconds = 0, wei
   return horizon > 0 ? curve.workBy(horizon) / horizon : curve.rateAt(0);
 }
 
+/**
+ * The summary the forecast reads, of a window of readings taken in any order:
+ * ordered by when each was taken, readings taken in the same millisecond kept
+ * apart. Null for no reading.
+ *
+ * @param {Array<{ at: number, speed?: number, value?: number }>} readings
+ * @returns {object | null}
+ */
+export function rateSummaryOf(readings) {
+  const ordered = (Array.isArray(readings) ? readings : [])
+    .map(reading => ({ at: reading?.at, value: reading?.value ?? reading?.speed }))
+    .filter(reading => Number.isFinite(reading.at) && Number.isFinite(reading.value) && reading.value >= 0)
+    .sort((left, right) => left.at - right.at);
+  return ordered.length > 0 ? summarizeRate(ordered) : null;
+}
+
 /**
  * Measurements over the output's existing look-ahead horizon. The oldest
  * boundary sample is retained until another sample replaces it, so a repeated
@@ -84,11 +100,6 @@ export class RateTrend {
     return true;
   }
 
-  /** The time of the newest reading kept, or -Infinity. */
-  get lastAt() {
-    return this.#readings.at(-1)?.at ?? Number.NEGATIVE_INFINITY;
-  }
-
   snapshot() {
     if (this.#readings.length === 0) {
       return null;