@torrent-tv/proxy 2.100.13 → 2.100.14

package/package.json

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

package/routes/transcode/variant-file/get.js

@@ -41,6 +41,22 @@ export async function handleTranscodeVariantFileGet(req, reply, { renditions, se
   if (refusedAsStale(req, reply, viewerRequests, fileName)) {
     return reply;
   }
+  // A held segment can be given to another output while it waits (a move
+  // between two outputs of this height); the request then resolves again.
+  for (;;) {
+    const answered = await serveResolved(req, reply, { renditions, serving, viewerRequests, baseSessionId, height, fileName, consumerId });
+    if (answered !== "reassigned") {
+      return answered;
+    }
+  }
+}
+
+/**
+ * Resolve the address once and answer it from what it resolves to.
+ *
+ * @returns {Promise<unknown>} "reassigned" when the held segment was given to another output meanwhile.
+ */
+async function serveResolved(req, reply, { renditions, serving, viewerRequests, baseSessionId, height, fileName, consumerId }) {
   const resolved = await renditions.resolveVariantFile(
     baseSessionId,
     height,
@@ -90,6 +106,7 @@ export async function handleTranscodeVariantFileGet(req, reply, { renditions, se
     serving,
     viewerRequests,
     sessionId: resolved.sessionId,
-    fileName
+    fileName,
+    stillGiven: () => renditions.stillGivenTo(baseSessionId, height, fileName, consumerId, statedGenerationOf(req), resolved.sessionId)
   });
 }

package/services/encode/Renditions.js

@@ -39,12 +39,12 @@ export class Renditions {
    * The segment each viewer's move was last said to wait for on the output
    * they are leaving, so that a wait is said once per segment.
    *
-   * @type {Map<string, number>}
+   * @type {Map<string, string>}
    */
   #moveWaitsSaid = new Map();
 
   /**
-   * @param {object} host - `viewerSecondsOn`, `audioStartSecondsFor`, `activeOutputFor`, `viewersOf`, `audioRenditionName`, `logger`, `placeViewer`, `viewerLeaves`, `createOrGetSession`, `planEncodersSoon`, `disposeSession`, `viewerPositionOf`, `encodeRuns`, `fileStartTimeReads`, `getCachedAudioTracks`, `getCachedMediaInfo`, `getContainerMediaInfo`, `localBaseUrl`, `outputTimes`, `outputs`, `quality`, `qualityOffer`, `segmentDurationSec`, `sourceFiles`, `viewers`, `generationOfRequest`, `givenOutputOf`, `noteGivenOutput`, `chosenOutputOf`, `chooseOutput`, `storedPieceReady`, `headersCompatible`, `audioChoiceOf`, `linkMbpsOf`, `qualityModeOf`, `noteServingVerdict`, `limitsFor`, `heightsChosenAs`, `highestGivenSegmentOf`, `sameHeightSwitchOf`, `noteSameHeightSwitch`, `switchingOnto`, `switchingFrom`, `segmentClosed`, `bufferedSecondsOf`, `minimumBufferSecondsFor`
+   * @param {object} host - `viewerSecondsOn`, `audioStartSecondsFor`, `activeOutputFor`, `viewersOf`, `audioRenditionName`, `logger`, `placeViewer`, `viewerLeaves`, `createOrGetSession`, `planEncodersSoon`, `disposeSession`, `viewerPositionOf`, `encodeRuns`, `fileStartTimeReads`, `getCachedAudioTracks`, `getCachedMediaInfo`, `getContainerMediaInfo`, `localBaseUrl`, `outputTimes`, `outputs`, `quality`, `qualityOffer`, `segmentDurationSec`, `sourceFiles`, `viewers`, `generationOfRequest`, `givenOutputOf`, `noteGivenOutput`, `chosenOutputOf`, `chooseOutput`, `storedPieceReady`, `headersCompatible`, `audioChoiceOf`, `linkMbpsOf`, `qualityModeOf`, `noteServingVerdict`, `limitsFor`, `heightsChosenAs`, `highestGivenSegmentOf`, `sameHeightSwitchOf`, `noteSameHeightSwitch`, `switchingOnto`, `switchingFrom`, `segmentClosed`, `secondsUntilClosed`, `invalidateWaits`, `bufferedSecondsOf`, `minimumBufferSecondsFor`
    */
   constructor(host) {
     this.#host = host;
@@ -997,31 +997,31 @@ export class Renditions {
       this.#cancelSameHeightSwitch(base, consumerId, "there is nothing left of the film to give from it");
       return;
     }
-    // A segment closed BEHIND the one they will ask for says nothing about it:
-    // the move would hand them an output that does not yet have what they need.
-    if (publishedIndex !== null && publishedIndex < next) {
-      return;
-    }
-    if (!this.#host.segmentClosed(prepared.outputKey ?? "", next)) {
-      return;
-    }
     // THE SEGMENT ALREADY GIVEN FROM THE OUTPUT ON SCREEN. A request is held by
     // the output it was given from, and leaving that output stops its encoder:
     // a segment given and not yet closed there would then be made by nobody.
     // On Home Assistant a viewer waiting for #2176 was moved from #2177 and
-    // the picture stood for good (r71, torrent-tv/meta#178). The move waits for
-    // that segment to be closed; an output whose encoding has failed for good
-    // closes nothing, and its held request is the serving path's to answer.
+    // the picture stood for good (r71, torrent-tv/meta#178). Nothing of it has
+    // been sent — only closed pieces are — so it is given by whichever output
+    // closes it sooner: the move then begins at it, or waits for it here. An
+    // output whose encoding has failed for good closes nothing, and its held
+    // request is the serving path's to answer.
     const open = this.#givenAndOpenOn(current, consumerId, move.askedHeights, next);
+    let from = next;
     if (open !== null && !this.#host.encodeRuns.hasFailed(current)) {
-      if (this.#moveWaitsSaid.get(consumerId) !== open) {
-        this.#moveWaitsSaid.set(consumerId, open);
-        this.#host.logger.info(
-          `transcode ${base.id} ${consumerId}'s move to ${move.outputKey} waits for #${open} on ` +
-          `${current.outputKey}, given and not yet closed there`
-        );
+      if (!this.#preparedClosesSooner(base, consumerId, move, current, prepared, open)) {
+        return;
+      }
+      from = open;
+    } else {
+      // A segment closed BEHIND the one they will ask for says nothing about it:
+      // the move would hand them an output that does not yet have what they need.
+      if (publishedIndex !== null && publishedIndex < next) {
+        return;
+      }
+      if (!this.#host.segmentClosed(prepared.outputKey ?? "", next)) {
+        return;
       }
-      return;
     }
     // THE CUSHION, for a move that is not urgent (roadmap item 98): a move up
     // is made once the viewer holds the cushion this file needs, and their
@@ -1053,7 +1053,58 @@ export class Renditions {
         return;
       }
     }
-    this.#completeSameHeightSwitch(base, consumerId, move, prepared, current, next);
+    if (from !== next) {
+      // The held request follows the address: it is woken, finds the segment
+      // given to the prepared output, and is answered from there.
+      const generation = this.#host.generationOfRequest(consumerId, Number.NaN);
+      for (const height of move.askedHeights) {
+        if (this.#host.givenOutputOf(consumerId, generation, height, from) === current.outputKey) {
+          this.#host.noteGivenOutput(consumerId, generation, height, from, prepared.outputKey ?? "");
+        }
+      }
+    }
+    this.#completeSameHeightSwitch(base, consumerId, move, prepared, current, from);
+    if (from !== next) {
+      this.#host.invalidateWaits?.(current);
+    }
+  }
+
+  /**
+   * Whether the output being prepared closes the segment held on the output on
+   * screen sooner than that output does, so that it is given from there.
+   *
+   * Both times are this machine's readings (`secondsUntilClosed`); either one
+   * unknown, or a header of the prepared output not proven to decode where the
+   * player's does, keeps the segment where it was given. Said once per segment
+   * and answer.
+   *
+   * @param {HlsSession} base
+   * @param {string} consumerId
+   * @param {object} move
+   * @param {HlsSession} current
+   * @param {HlsSession} prepared
+   * @param {number} index - The segment held on `current`.
+   * @returns {boolean}
+   */
+  #preparedClosesSooner(base, consumerId, move, current, prepared, index) {
+    const now = Date.now();
+    const onCurrent = this.#host.secondsUntilClosed?.(current, index, now) ?? null;
+    const onPrepared = this.#host.secondsUntilClosed?.(prepared, index, now) ?? null;
+    const withInit = current.segmentFormat?.initFileName !== null && prepared.segmentFormat?.initFileName !== null;
+    const compatible = !withInit || this.#host.headersCompatible(current.outputKey, prepared.outputKey)?.compatible === true;
+    const sooner = compatible && onCurrent !== null && onPrepared !== null && onPrepared < onCurrent;
+    const said = `${index}:${sooner}`;
+    if (this.#moveWaitsSaid.get(consumerId) !== said) {
+      this.#moveWaitsSaid.set(consumerId, said);
+      const time = (seconds) => (seconds === null ? "unknown" : `${seconds.toFixed(1)}s`);
+      this.#host.logger.info(
+        `transcode ${base.id} ${consumerId}'s move to ${move.outputKey}: #${index}, given from ${current.outputKey} ` +
+        `and not closed there, closes there in ${time(onCurrent)} and on the prepared output in ${time(onPrepared)}` +
+        (compatible ? "" : " (its header is not proven to decode where the player's does)") +
+        ` — ${sooner ? "given from the prepared output, the move begins at it" : "the move waits for it there"}`
+      );
+    }
+    return sooner;
   }
 
   /**
@@ -1358,6 +1409,32 @@ export class Renditions {
    * @returns {Promise<{ sessionId: string | null, error?: string }>} The session
    *   to serve the file from; a null id means there is no such variant.
    */
+  /**
+   * Whether this address is still given to the output a held request for it
+   * waits on. A move may give a segment that is not closed yet to the output
+   * the viewer is moved to (`#preparedClosesSooner`); the held request then
+   * asks again and is answered from there.
+   *
+   * @param {string} baseSessionId
+   * @param {number} height
+   * @param {string} fileName
+   * @param {string} consumerId
+   * @param {number} statedGeneration
+   * @param {string} sessionId - The output the request waits on.
+   * @returns {boolean}
+   */
+  stillGivenTo(baseSessionId, height, fileName, consumerId, statedGeneration, sessionId) {
+    const base = isOutputName(baseSessionId) ? this.#host.outputs.get(baseSessionId) : null;
+    const waitedOn = this.#host.outputs.get(sessionId);
+    const index = base?.segmentFormat?.segmentIndexFromName?.(fileName);
+    if (!base || !waitedOn || !consumerId || !Number.isInteger(index) || index < 0) {
+      return true;
+    }
+    const generation = this.#host.generationOfRequest(consumerId, statedGeneration);
+    const key = this.#host.givenOutputOf(consumerId, generation, height, index);
+    return !key || key === waitedOn.outputKey;
+  }
+
   async resolveVariantFile(baseSessionId, height, fileName, consumerId = "", statedGeneration = Number.NaN) {
     if (!isOutputName(baseSessionId)) {
       return { sessionId: null };

package/services/encode/piece-close-time.js

@@ -0,0 +1,64 @@
+/**
+ * @file How long until a piece of an output is closed, from what is measured
+ * about that output's runs (torrent-tv/meta#178).
+ *
+ * Asked when a viewer is moved between two outputs of one height while a piece
+ * given to them from the output on screen is not closed yet: the piece is then
+ * given by whichever output closes it sooner. Every term is a reading of this
+ * machine; a term that is not known makes the answer unknown, never a guess.
+ */
+
+/**
+ * Seconds until the piece is closed on its output, or null when that cannot be
+ * said.
+ *
+ * 1. A closed piece: 0.
+ * 2. A live run whose stretch holds the piece: the film from where the run has
+ *    reached to the piece's end, at the output's speed, plus what is left of
+ *    the run's opening when it has produced nothing yet.
+ * 3. No such run: a run opened here for it — the output's measured opening and
+ *    the whole piece at its speed.
+ *
+ * @param {object} what
+ * @param {boolean} what.closed
+ * @param {number} what.index - The piece.
+ * @param {number} what.pieceStart - Where the piece begins, seconds of film.
+ * @param {number} what.pieceEnd - Where it ends.
+ * @param {Array<{ from: number, to: number, startedAt: number, startSeconds: number, reachedSeconds: number | null }>} what.runs
+ *   The output's live runs: their stretch (`to` −1 for one with no end), when
+ *   each started, where it began and how far it has produced.
+ * @param {number | null} what.speed - Seconds of film the output makes per second.
+ * @param {number | null} what.openSeconds - What opening a run costs this output.
+ * @param {number} what.now
+ * @returns {number | null}
+ */
+export function secondsUntilClosed({ closed, index, pieceStart, pieceEnd, runs, speed, openSeconds, now }) {
+  if (closed) {
+    return 0;
+  }
+  if (!(speed > 0) || !Number.isFinite(pieceStart) || !Number.isFinite(pieceEnd) || pieceEnd <= pieceStart) {
+    return null;
+  }
+  const holding = runs.filter((run) => run.from <= index && (run.to < 0 || run.to >= index));
+  let best = null;
+  for (const run of holding) {
+    const reached = Number.isFinite(run.reachedSeconds) && run.reachedSeconds > run.startSeconds
+      ? run.reachedSeconds : null;
+    let seconds;
+    if (reached !== null) {
+      seconds = Math.max(0, pieceEnd - reached) / speed;
+    } else {
+      if (!Number.isFinite(openSeconds)) continue;
+      const opened = Math.max(0, (now - run.startedAt) / 1000);
+      seconds = Math.max(0, openSeconds - opened) + Math.max(0, pieceEnd - run.startSeconds) / speed;
+    }
+    best = best === null ? seconds : Math.min(best, seconds);
+  }
+  if (best !== null) {
+    return best;
+  }
+  if (holding.length > 0 || !Number.isFinite(openSeconds)) {
+    return null;
+  }
+  return openSeconds + (pieceEnd - pieceStart) / speed;
+}

package/services/server/transcode-session-files.js

@@ -71,10 +71,13 @@ export function refusedAsStale(req, reply, viewerRequests, fileName) {
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ serving: object, viewerRequests: object, sessionId: string, fileName: string }} params
- * @returns {Promise<void>}
+ * @param {{ serving: object, viewerRequests: object, sessionId: string, fileName: string, stillGiven?: () => boolean }} params
+ *   `stillGiven`: whether the address is still given to this session; when it
+ *   stops being, nothing is answered and "reassigned" is returned for the
+ *   caller to resolve the address again.
+ * @returns {Promise<void | "reassigned">}
  */
-export async function serveSessionFile(req, reply, { serving, viewerRequests, sessionId, fileName }) {
+export async function serveSessionFile(req, reply, { serving, viewerRequests, sessionId, fileName, stillGiven = null }) {
   // Which viewer is asking. One session serves everyone watching a copied
   // picture, so without it their positions collapse into one and a seek by the
   // viewer in front releases the requests held for the viewer behind. Absent on
@@ -100,13 +103,18 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
   try {
     result = await waitForSessionFile(serving, sessionId, fileName, {
       until: clientGone,
-      consumerId
+      consumerId,
+      stillGiven
     });
   } finally {
     req.raw.off("aborted", onClientAbort);
     reply.raw?.off("close", onResponseClose);
   }
   const heldMs = Date.now() - holdStartedAt;
+  if (!clientAborted && result.kind === "reassigned") {
+    logger.info(`[hold] ${fileName} given to another output after ${heldMs}ms; asked again there`);
+    return "reassigned";
+  }
   if (clientAborted || result.kind === "cancelled") {
     logger.info(`[hold] request=${req.id ?? "unknown"} ${fileName} cancelled after ${heldMs}ms`);
     result.stream?.destroy?.();
@@ -234,7 +242,7 @@ export async function waitForRequestedFile(req, reply, serving, sessionId, fileN
   }
 }
 
-export async function waitForSessionFile(serving, sessionId, fileName, { until = null, consumerId = "" } = {}) {
+export async function waitForSessionFile(serving, sessionId, fileName, { until = null, consumerId = "", stillGiven = null } = {}) {
   let gone = false;
   const requesterGone = until ? until.then(() => { gone = true; }) : new Promise(() => {});
   // The viewer's position when this request was made. A seek makes every held
@@ -249,6 +257,9 @@ export async function waitForSessionFile(serving, sessionId, fileName, { until =
   while (!gone) {
     const change = serving.subscribeFileChange(sessionId);
     try {
+    if (stillGiven && !stillGiven()) {
+      return { kind: "reassigned" };
+    }
     const result = await serving.getFileStream(sessionId, fileName, { consumerId });
     if (gone) {
       result.stream?.destroy?.();

package/services/server/wire-outputs.js

@@ -102,6 +102,7 @@ import { configurationKeyOf } from "../encode/fingerprint.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
 import { downloadShare } from "../storage/processor-share.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode/encode-run-state.js";
+import { secondsUntilClosed } from "../encode/piece-close-time.js";
 
 // Where a variant and an audio rendition live under a session — `v/<height>/…`
 // and `a/<track>/…` — is stated in `encode/output/playlists.js`, beside the lines that
@@ -460,6 +461,29 @@ export function wireOutputs({
     // asked before a preparation is recorded.
     admitsPreparation: (output) => parts.admission.admitsPreparation(output?.outputKey ?? ""),
     segmentClosed: (key, index) => parts.segmentStore.isClosed(key, index),
+    // How long until a piece is closed on an output, from that output's runs and
+    // the rate the start forecast reads for it (`encode/piece-close-time.js`).
+    secondsUntilClosed: (output, index, now) => {
+      const readings = parts.encodeRuns.speedReadingsOf(output).filter((reading) => reading.at <= now);
+      const summary = readings.length > 0 ? rateSummaryOf(readings) : null;
+      const speed = summary ? forecastRate(summary, now, 0, "piece") : parts.encodeCost.projectedSpeedOf(output);
+      return secondsUntilClosed({
+        closed: parts.segmentStore.isClosed(output.outputKey ?? "", index),
+        index,
+        pieceStart: output.timeline?.publishedStartOf?.(index),
+        pieceEnd: output.timeline?.publishedStartOf?.(index + 1),
+        runs: parts.encodeRuns.liveRunsOf(output).map((run) => ({
+          from: run.from,
+          to: Number.isInteger(run.to) ? run.to : -1,
+          startedAt: run.startedAt,
+          startSeconds: run.progress.startPositionSeconds,
+          reachedSeconds: run.progress.processedSeconds
+        })),
+        speed: Number.isFinite(speed) ? speed : null,
+        openSeconds: runStartSecondsOf(output),
+        now
+      });
+    },
     // What a gone output left in the store, and whether another output's header
     // may stand in for its own.
     storedPieceReady: (key, fileName) => parts.serving.hasStoredPiece(key, fileName),