@torrent-tv/proxy 2.98.6 → 2.98.8

package/package.json

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

package/services/encode/EncodeInputs.js

@@ -273,7 +273,15 @@ export class EncodeInputs {
   bytesChanged(arrived = null) {
     this.#revision++;
     for (const request of this.#requests.values()) {
-      if (request.pending || request.result?.kind === "result" || request.result?.kind === "terminal") continue;
+      if (request.pending) {
+        // The try in flight may have read before these bytes came. What it
+        // waits for is known only when it answers, so they are kept for that
+        // answer; bytes not named make it try again whatever it answers.
+        if (!arrived) request.unnamedArrival = true;
+        else (request.arrivedMeanwhile ??= []).push(arrived);
+        continue;
+      }
+      if (request.result?.kind === "result" || request.result?.kind === "terminal") continue;
       if (arrived && request.result?.kind === "needs-bytes" && !awaitedIn(request.result, arrived)) {
         // Nothing it waits for has come: it stands as tried at this revision.
         request.revision = this.#revision;
@@ -341,6 +349,8 @@ export class EncodeInputs {
     request.pending = true;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
+    request.arrivedMeanwhile = null;
+    request.unnamedArrival = false;
     // Where the time from the request to its input goes, across every attempt:
     // field 2026-10-10, a picture's request took 38 s before its copy began and
     // nothing said on what (torrent-tv/meta#166).
@@ -382,12 +392,29 @@ export class EncodeInputs {
       request.pending = false;
       if (request.result?.kind !== "needs-memory") this.#wanted.delete(request.key);
       const changed = request.result?.kind === "needs-memory"
-        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision;
+        ? request.memoryRevision !== this.#memoryRevision : this.#arrivedFor(request);
       if (this.#requests.get(request.key) === request && changed &&
         request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
     });
   }
 
+  /**
+   * Whether bytes came during a try that the try may have missed. A try that
+   * waits for named bytes is repeated only when some of them came, or when an
+   * event named nothing; the others stand it as tried at this revision. In r36
+   * a held-range check took 344 ms, and a piece of the file arriving during it
+   * started another (torrent-tv/meta#178).
+   */
+  #arrivedFor(request) {
+    if (request.revision === this.#revision) return false;
+    const arrivals = request.arrivedMeanwhile ?? [];
+    request.arrivedMeanwhile = null;
+    if (request.unnamedArrival || request.result?.kind !== "needs-bytes" ||
+      arrivals.some(arrived => awaitedIn(request.result, arrived))) return true;
+    request.revision = this.#revision;
+    return false;
+  }
+
   /** The reservation a packet input makes: all of it, or nothing. */
   #reserveFor(request) {
     return async bytes => {

package/services/server/ViewerRequests.js

@@ -60,7 +60,13 @@ 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`. */
+  /**
+   * 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();
 
   /**
@@ -658,6 +664,7 @@ export class ViewerRequests {
           this.#host.initialOutputBitsPerMediaSecondOf?.(output) ?? 0,
         readings: trackRates,
         segments,
+        geometry: this.#forecastPieces.get(output)?.geometry,
         readySegmentIndices: [...inventory.keys()],
         segmentSizesBytes: inventory
       });
@@ -808,11 +815,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);

package/services/viewer/playback-readiness.js

@@ -139,21 +139,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 +640,69 @@ 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
+ * the same pieces, the same timescale and the same clock offset, so no time is
+ * rounded for the reuse.
+ *
+ * @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;
+  if (geometry && samePieces(geometry.pieces, segments)) return geometry.timescale;
+  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) => ({ 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. Reused while the pieces are those
+ * {@link timescaleOfPieces} last took and `unit` and `clock` are the same.
+ *
+ * @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;
+  if (geometry?.placed && geometry.placedUnit === unit && geometry.placedClock === clock.ticks) return geometry.placed;
+  const placed = predictedMediaSegments((Array.isArray(track.segments) ? track.segments : []).map((segment) => ({
+    ...segment, exact: exactTimesOf(segment), ranges: playerRanges(segment.mediaRanges, clock, unit)
+  })), unit);
+  if (geometry) Object.assign(geometry, { placed, placedUnit: unit, placedClock: clock.ticks });
+  return placed;
+}
+
+/** Whether `segments` are the pieces `kept` recorded, field by field the forecast reads. */
+function samePieces(kept, segments) {
+  if (!Array.isArray(kept) || kept.length !== segments.length) return false;
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index], was = kept[index];
+    if (segment !== was.segment || segment.index !== was.index || segment.startSeconds !== was.startSeconds ||
+      segment.endSeconds !== was.endSeconds || segment.mediaRanges !== was.mediaRanges) return false;
+  }
+  return true;
 }
 
 /**

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 */