@torrent-tv/proxy 2.98.7 → 2.98.9

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -10,6 +10,8 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { contentionPenalty } from "./contention.js";
+import { LOOKAHEAD_PAUSE_SECONDS } from "./CushionReport.js";
+import { SpeedReadings } from "./SpeedReadings.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";
@@ -171,6 +173,8 @@ export class EncodeRuns {
    * @type {WeakMap<object, { cpuSeconds: number, filmSeconds: number, reading: boolean, beside: number }>}
    */
   #cpuOfRun = new WeakMap();
+  /** Every speed reading of each output's runs, for the start forecast (`SpeedReadings.js`). */
+  #speedReadings = new SpeedReadings(LOOKAHEAD_PAUSE_SECONDS);
 
   #lastInputToken = 0;
   #inputFailures = new InputFailures();
@@ -492,6 +496,18 @@ export class EncodeRuns {
     }
   }
 
+  /**
+   * The speed readings of this output's runs measured after `after`, oldest
+   * first, within the forecast's horizon.
+   *
+   * @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);
+  }
+
   /**
    * The media intervals of a stored piece of this output, or undefined.
    *
@@ -1179,7 +1195,10 @@ export class EncodeRuns {
       // group before it in hand — the leading pictures the run that starts
       // there cannot make.
       onTail: (name) => this.#keepLeadingPictures(session, admittedInput, name),
-      onSpeedMeasured: () => this.#host.noteRunSpeedMeasured?.(session, run),
+      onSpeedMeasured: (reading) => {
+        this.#speedReadings.note(session, reading);
+        this.#host.noteRunSpeedMeasured?.(session, run);
+      },
       onEnded: (ended) => {
         this.#runsByInputToken.delete(inputToken);
         if (admittedInput.original) {

package/services/encode/SpeedReadings.js

@@ -0,0 +1,45 @@
+/**
+ * @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
+ * 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
+ * on 0.78x for 13 s (r37).
+ */
+
+export class SpeedReadings {
+  /** @type {WeakMap<object, Array<{ speed: number, at: number }>>} */
+  #byOutput = new WeakMap();
+  #keepMs;
+
+  /** @param {number} keepSeconds - How far back a reading is kept: the forecast's horizon. */
+  constructor(keepSeconds) {
+    this.#keepMs = Math.max(0, keepSeconds) * 1000;
+  }
+
+  /**
+   * @param {object} output
+   * @param {{ speed: number, at: number } | null} reading
+   */
+  note(output, reading) {
+    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;
+    // 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.
+   */
+  after(output, after = Number.NEGATIVE_INFINITY) {
+    return (this.#byOutput.get(output) ?? []).filter(reading => reading.at > after);
+  }
+}

package/services/server/ViewerRequests.js

@@ -60,11 +60,38 @@ export class ViewerRequests {
   #host;
   /** @type {WeakMap<object, Map<string, object>>} */
   #rateStateBySession = new WeakMap();
-  /** The pieces of each output as the start forecast read them last; see `#segmentsOf`. */
+  /**
+   * What the start forecasts cost, said once a minute: how many there were,
+   * their time on the main thread, and for each track whether the times of its
+   * pieces were kept from the last poll or why they were worked out again. In
+   * r37 the forecast took 19.2 s of Home Assistant's main thread in 15 minutes
+   * and the times were mostly worked out again (torrent-tv/meta#178).
+   */
+  #forecastCosts = { since: Date.now(), polls: 0, ms: 0, maxMs: 0, times: new Map() };
+
+  #noteForecast(ms, reasons) {
+    const costs = this.#forecastCosts;
+    costs.polls += 1; costs.ms += ms; costs.maxMs = Math.max(costs.maxMs, ms);
+    for (const reason of reasons) costs.times.set(reason, (costs.times.get(reason) ?? 0) + 1);
+    const now = Date.now();
+    if (now - costs.since < 60_000) return;
+    logger.info(`start forecasts in ${((now - costs.since) / 1000).toFixed(1)}s: ${costs.polls}, ` +
+      `${Math.round(costs.ms)}ms in all, ${(costs.ms / costs.polls).toFixed(1)}ms each, longest ${Math.round(costs.maxMs)}ms; ` +
+      `times of a track's pieces: ${[...costs.times].map(([reason, count]) => `${reason} ${count}`).join(", ")}`);
+    Object.assign(costs, { since: now, polls: 0, ms: 0, maxMs: 0, times: new Map() });
+  }
+
+  /**
+   * The pieces of each output as the start forecast read them last (see
+   * `#segmentsOf`), and what the forecast keeps of their time geometry while
+   * they stand (`playback-readiness.js` `timescaleOfPieces`).
+   *
+   * @type {WeakMap<object, { pieces: object[], geometry: object }>}
+   */
   #forecastPieces = new WeakMap();
 
   /**
-   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
+   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `disposeSession`, `planEncodersSoon`, `waitUntilReady`, `encodeRuns`, `encodeSpeedReadingsOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
    */
   constructor(host) {
     this.#host = host;
@@ -658,6 +685,7 @@ export class ViewerRequests {
           this.#host.initialOutputBitsPerMediaSecondOf?.(output) ?? 0,
         readings: trackRates,
         segments,
+        geometry: this.#forecastPieces.get(output)?.geometry,
         readySegmentIndices: [...inventory.keys()],
         segmentSizesBytes: inventory
       });
@@ -710,7 +738,10 @@ export class ViewerRequests {
     // fetched whole by the page before it is chosen, so it never matches here.
     const subtitle = viewer?.subtitle?.sourceKey === session.file.sourceKey &&
       viewer.subtitle.fileIndex === session.file.fileIndex ? viewer.subtitle : null;
-    const forecast = withSubtitleReadiness(this.#host.playbackReadiness.predict(input), subtitle,
+    const startedAt = performance.now();
+    const predicted = this.#host.playbackReadiness.predict(input);
+    this.#noteForecast(performance.now() - startedAt, tracks.map(track => track.geometry?.reason ?? "none"));
+    const forecast = withSubtitleReadiness(predicted, subtitle,
       subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
     forecast.operations = outputs.flatMap((output, index) => {
       const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings, now, 0, "piece"),
@@ -808,11 +839,12 @@ export class ViewerRequests {
   #segmentsOf(output, sessionInit, inventory, positionSeconds) {
     const timeline = output.timeline;
     const count = timeline?.segmentCount ?? 0;
-    let kept = this.#forecastPieces.get(output);
-    if (!kept) {
-      kept = [];
-      this.#forecastPieces.set(output, kept);
+    let forecast = this.#forecastPieces.get(output);
+    if (!forecast) {
+      forecast = { pieces: [], geometry: {} };
+      this.#forecastPieces.set(output, forecast);
     }
+    const kept = forecast.pieces;
     const segments = [];
     for (let index = 0; index < count; index++) {
       const endSeconds = timeline.publishedStartOf(index + 1);
@@ -861,10 +893,12 @@ export class ViewerRequests {
       trend = new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds);
       state.tracks.set(id, trend);
     }
-    const reading = this.#host.encodeSpeedReadingOf?.(output, now) ?? null;
-    if (Number.isFinite(reading?.speed) && reading.speed > 0 && Number.isFinite(reading.at)) {
-      trend.add(reading.at, reading.speed);
-    } else if (!trend.snapshot()) {
+    // 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()) {
       // 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

package/services/server/wire-outputs.js

@@ -583,7 +583,7 @@ export function wireOutputs({
     // source preparation's answer, set on these parts by the assembly.
     subtitleReadyFor: (viewer) => parts.subtitleReadyFor?.(viewer) ?? true,
     sourceInputsFor: (output, index) => parts.sourceInputsFor?.(output, index),
-    encodeSpeedReadingOf: (output) => parts.encodeCost.latestSpeedReadingOf(output),
+    encodeSpeedReadingsOf: (output, after) => parts.encodeRuns.speedReadingsOf(output, after),
     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

@@ -84,6 +84,11 @@ 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;
@@ -139,21 +144,16 @@ export function predictPlaybackReadiness(input = {}) {
       range.end > range.start).map((range) => ({ start: fromSeconds(range.start), end: fromSeconds(range.end) }))
     : null);
   // One timescale in which every time of this forecast is a whole number of
-  // ticks, so that adding and comparing never seek a common denominator.
+  // ticks, so that adding and comparing never seek a common denominator. A
+  // track's pieces give it the same timescale while they are the same pieces.
   const unit = commonTimescale([
     fromSeconds(finiteNonNegative(input.positionSeconds)), fromSeconds(duration),
     fromSeconds(finiteNonNegative(input.bufferedAheadSeconds)), REPORTED_TIME_ERROR, ...clocks,
     ...reported.flatMap((ranges) => (ranges ?? []).flatMap(({ start, end }) => [start, end])),
-    ...tracks.flatMap((track) => (Array.isArray(track.segments) ? track.segments : []).flatMap((segment) => [
-      ...(segment.mediaRanges?.timescale ? [mediaTime(0n, segment.mediaRanges.timescale)] : []),
-      ...exactBoundsOf(segment)
-    ]))
+    ...tracks.map((track) => mediaTime(0n, timescaleOfPieces(track)))
   ]);
   const zero = mediaTime(0n, unit);
-  const segmentsOf = tracks.map((track, trackIndex) => predictedMediaSegments(
-    (Array.isArray(track.segments) ? track.segments : []).map((segment) => ({
-      ...segment, exact: exactTimesOf(segment), ranges: playerRanges(segment.mediaRanges, rescale(clocks[trackIndex], unit), unit)
-    })), unit));
+  const segmentsOf = tracks.map((track, trackIndex) => placedPieces(track, rescale(clocks[trackIndex], unit), unit));
   const origin = latest(zero, ...segmentsOf.map((segments) =>
     segments.find(({ index }) => index === 0)?.ranges?.[0]?.start ?? zero));
   const at = latest(origin, rescale(fromSeconds(finiteNonNegative(input.positionSeconds)), unit));
@@ -645,10 +645,86 @@ function timesOf(segment) {
   return segment.exact ?? exactTimesOf(segment);
 }
 
-/** @returns {import("./media-time.js").MediaTime[]} The finite playlist edges of a piece, exactly. */
-function exactBoundsOf(segment) {
-  const { start, end } = exactTimesOf(segment);
-  return [start, end].filter(Boolean);
+/**
+ * WHAT A TRACK'S PIECES GIVE THE FORECAST'S TIME, KEPT BETWEEN POLLS while
+ * they are the same pieces. The forecast runs on every poll of a waiting
+ * viewer, and gathering the edges of every remaining piece for the timescale,
+ * then placing each on the page's clock, was about 3 s of the proxy's main
+ * thread in r35's first 15 minutes on Home Assistant (torrent-tv/meta#178).
+ * `track.geometry` is kept by whoever keeps the pieces; without it nothing is
+ * kept, and the answer is the same either way: a placement is reused only for
+ * pieces with the same edges and read ranges, the same timescale and the same
+ * clock offset, so no time is rounded for the reuse. Only the times are kept: a
+ * piece whose torrent inputs were told again is a new object with the same
+ * times, and it is read with its inputs of this poll. In r37 most polls placed
+ * every piece again, the MPEG-TS output having no read ranges to keep them by.
+ *
+ * @param {{ segments?: object[], geometry?: object }} track
+ * @returns {bigint} The least timescale holding every edge and every served tick of its pieces.
+ */
+function timescaleOfPieces(track) {
+  const segments = Array.isArray(track.segments) ? track.segments : [];
+  const geometry = track.geometry;
+  const changed = geometry ? piecesChanged(geometry.pieces, segments) : null;
+  if (geometry && changed === null) return geometry.timescale;
+  if (geometry) geometry.reason = changed;
+  const distinct = new Set();
+  for (const segment of segments) {
+    if (segment.mediaRanges?.timescale) distinct.add(segment.mediaRanges.timescale);
+    const { start, end } = exactTimesOf(segment);
+    if (start) distinct.add(start.timescale);
+    if (end) distinct.add(end.timescale);
+  }
+  const timescale = commonTimescale([...distinct].map((value) => mediaTime(0n, value)));
+  if (geometry) {
+    geometry.pieces = segments.map((segment) => ({ index: segment.index, startSeconds: segment.startSeconds,
+      endSeconds: segment.endSeconds, mediaRanges: segment.mediaRanges }));
+    geometry.timescale = timescale;
+    geometry.placed = null;
+  }
+  return timescale;
+}
+
+/**
+ * A track's pieces on the page's clock in `unit`: read pieces at their served
+ * ranges, the others placed between them. The times are reused while the
+ * pieces are those {@link timescaleOfPieces} last took and `unit` and `clock`
+ * are the same; everything else of a piece is this poll's.
+ *
+ * @param {{ segments?: object[], geometry?: object }} track
+ * @param {import("./media-time.js").MediaTime} clock - In `unit`.
+ * @param {bigint} unit
+ */
+function placedPieces(track, clock, unit) {
+  const geometry = track.geometry;
+  const segments = Array.isArray(track.segments) ? track.segments : [];
+  let times = geometry?.placed && geometry.placedUnit === unit && geometry.placedClock === clock.ticks ? geometry.placed : null;
+  if (geometry) geometry.reason = times ? "kept" : !geometry.placed ? geometry.reason ?? "first" : geometry.placedUnit !== unit ? "timescale" : "clock";
+  if (!times) {
+    times = predictedMediaSegments(segments.map((segment) => ({
+      ...segment, exact: exactTimesOf(segment), ranges: playerRanges(segment.mediaRanges, clock, unit)
+    })), unit).map(({ exact, ranges }) => ({ exact, ranges }));
+    if (geometry) Object.assign(geometry, { placed: times, placedUnit: unit, placedClock: clock.ticks });
+  }
+  return segments.map((segment, index) => ({ ...segment, exact: times[index].exact, ranges: times[index].ranges }));
+}
+
+/**
+ * How `segments` differ from the pieces `kept` recorded, by the first field
+ * their times come from that differs, or null when they are the same pieces.
+ *
+ * @returns {"first" | "count" | "index" | "edges" | "read ranges" | null}
+ */
+function piecesChanged(kept, segments) {
+  if (!Array.isArray(kept)) return "first";
+  if (kept.length !== segments.length) return "count";
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index], was = kept[index];
+    if (segment.index !== was.index) return "index";
+    if (segment.startSeconds !== was.startSeconds || segment.endSeconds !== was.endSeconds) return "edges";
+    if (segment.mediaRanges !== was.mediaRanges) return "read ranges";
+  }
+  return null;
 }
 
 /**

package/services/viewer/segment-input-table.js

@@ -10,7 +10,7 @@
  */
 
 export class SegmentInputTable {
-  /** `sourceKey` → output → segment → file → its ranges. @type {Map<string, Map<string, Map<number, Map<number, { joined: Array<[number, number]>, ranges: Array<{ start: number, end: number }> }>>>>} */
+  /** `sourceKey` → output → segment → its files' ranges, and the list `inputsFor` answers while they stand. @type {Map<string, Map<string, Map<number, { files: Map<number, { joined: Array<[number, number]>, ranges: Array<{ start: number, end: number }> }>, inputs: Array<{ sourceId: string, ranges: Array<{ start: number, end: number }> }> | null }>>>} */
   #bySource = new Map();
 
   /**
@@ -25,15 +25,19 @@ export class SegmentInputTable {
     if (!outputs) this.#bySource.set(sourceKey, outputs = new Map());
     let segments = outputs.get(outputKey);
     if (!segments) outputs.set(outputKey, segments = new Map());
-    let files = segments.get(index);
-    if (!files) segments.set(index, files = new Map());
+    let segment = segments.get(index);
+    if (!segment) segments.set(index, segment = { files: new Map(), inputs: null });
     // The same reading keeps its list: whoever compares inputs compares them by it.
-    if (files.get(fileIndex)?.joined === joined) return;
-    files.set(fileIndex, { joined, ranges: joined.map(([start, end]) => ({ start, end: end + 1 })) });
+    if (segment.files.get(fileIndex)?.joined === joined) return;
+    segment.files.set(fileIndex, { joined, ranges: joined.map(([start, end]) => ({ start, end: end + 1 })) });
+    segment.inputs = null;
   }
 
   /**
-   * The bytes one segment reads, by file, or null where none are known.
+   * The bytes one segment reads, by file, or null where none are known. The
+   * same list while they stand: the start forecast asks for every segment of
+   * the film on each poll, and keeps what it derived from a segment whose
+   * inputs are the same list.
    *
    * @param {string} sourceKey
    * @param {string} outputKey
@@ -41,9 +45,10 @@ export class SegmentInputTable {
    * @returns {Array<{ sourceId: string, ranges: Array<{ start: number, end: number }> }> | null}
    */
   inputsFor(sourceKey, outputKey, index) {
-    const files = this.#bySource.get(sourceKey)?.get(outputKey)?.get(index);
-    if (!files?.size) return null;
-    return [...files].map(([fileIndex, { ranges }]) => ({ sourceId: `${sourceKey}:${fileIndex}`, ranges }));
+    const segment = this.#bySource.get(sourceKey)?.get(outputKey)?.get(index);
+    if (!segment?.files.size) return null;
+    segment.inputs ??= [...segment.files].map(([fileIndex, { ranges }]) => ({ sourceId: `${sourceKey}:${fileIndex}`, ranges }));
+    return segment.inputs;
   }
 
   /** @param {string} sourceKey */