@torrent-tv/proxy 2.94.1 → 2.94.2

package/package.json

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

package/services/server/ViewerRequests.js

@@ -9,6 +9,7 @@
 
 import { logger } from "../../utils/logger.js";
 import { isOutputName } from "../encode/output/index.js";
+import { withSubtitleReadiness } from "./subtitle-readiness.js";
 
 function isWarmupTimeoutError(error) {
   if (!(error instanceof Error)) {
@@ -696,7 +697,13 @@ export class ViewerRequests {
       tracks,
       linkReadings: measurement.link.snapshot()
     };
-    const forecast = this.#host.playbackReadiness.predict(input);
+    // A subtitle track chosen inside THIS file is the last input the forecast
+    // waits for. A subtitle FILE beside it is named by its own index and is
+    // 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,
+      subtitle ? this.#host.subtitleReadyFor?.(viewer) !== false : true);
     forecast.operations = outputs.flatMap((output, index) => {
       const common = { speed: this.#host.playbackReadiness.forecastRate(tracks[index].readings), processedSeconds: tracks[index].processedSeconds };
       return [

package/services/server/subtitle-readiness.js

@@ -0,0 +1,38 @@
+/**
+ * @file The subtitle a viewer has chosen, as a term of their playback readiness.
+ *
+ * A file that says which subtitle to show — `FlagDefault` — is saying the film
+ * is to be watched with it, the opening included. Starting the picture before
+ * that track's cues have been read where the viewer stands showed the opening
+ * without them (torrent-tv/meta#8). So the chosen track is one more input the
+ * forecast waits for, beside the picture and the separately published sound.
+ *
+ * **What bounds the wait.** The read it waits for is one segment of that track
+ * at the viewer's position (`SourcePreparation`, the `subtitle-embedded`
+ * work), demanded at the picture's own urgency. It ends with the cues or with
+ * the proxy's refusal to read the track, and `subtitleReadyFor` counts both.
+ * No time limit is added: there is no measured figure to set one from, and the
+ * bytes it needs are the ones beside the picture's own at the same position.
+ *
+ * The answer always carries `subtitles`, `null` included, so the page can tell
+ * a proxy that weighed the chosen track from one that never heard of it.
+ */
+
+/**
+ * @param {object} forecast - What `predictPlaybackReadiness` answered.
+ * @param {{ fileIndex: number, trackIndex: number | null } | null} selection -
+ *   The subtitle this viewer chose, for the file being opened; null for none.
+ * @param {boolean} ready - Whether that subtitle has been read where they stand.
+ * @returns {object} The forecast, holding for the subtitle where it must.
+ */
+export function withSubtitleReadiness(forecast, selection, ready) {
+  const subtitles = selection
+    ? { fileIndex: selection.fileIndex, trackIndex: selection.trackIndex, ready: ready === true }
+    : null;
+  if (forecast?.ready !== true || !subtitles || subtitles.ready) {
+    return { ...forecast, subtitles };
+  }
+  // No delay: the forecast's figure is the picture's, which is already met, and
+  // no rate predicts when a read of a few cues finishes.
+  return { ...forecast, ready: false, delaySeconds: null, reason: "subtitles-pending", subtitles };
+}

package/services/server/wire-outputs.js

@@ -572,6 +572,9 @@ export function wireOutputs({
     // 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 },
+    // 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),
     encodeSpeedReadingOf: (output) => parts.encodeCost.latestSpeedReadingOf(output),
     projectedEncodeSpeedOf: (output) => parts.encodeCost.projectedSpeedOf(output),

package/services/viewer/SourcePreparation.js

@@ -104,14 +104,26 @@ export class SourcePreparation {
       work.positions === this.#positionsFor(work.sourceKey, work.fileIndex, viewer.id));
   }
 
+  /**
+   * Whether the subtitle this viewer chose has been read where they stand.
+   *
+   * Playback readiness waits on this (`subtitle-readiness.js`), so every way
+   * the read can END must answer it, and a refusal is one of them. The cues
+   * are the last of four reads — the track table, the media info, the packet
+   * index, then the cues — and a refusal at an earlier step means the later
+   * ones are never asked. Counting only the cues' own answer left a track the
+   * proxy cannot read waiting for ever.
+   */
   subtitleReadyFor(viewer) {
     const selection = viewer.subtitle;
     if (!selection) return true;
+    const positions = () => this.#positionsFor(selection.sourceKey, selection.fileIndex, viewer.id, true);
     return [...this.#work.values()].some(work => work.sourceKey === selection.sourceKey &&
       work.fileIndex === selection.fileIndex && ["result", "terminal"].includes(work.result) &&
       (selection.trackIndex === null ? work.statement === "subtitle-file" && work.ownerFileIndex === viewer.source.selectedFileIndex
-        : work.statement === "subtitle-cues" && work.ownerId === viewer.id && work.trackIndex === selection.trackIndex &&
-          work.positions === this.#positionsFor(work.sourceKey, work.fileIndex, viewer.id, true)));
+        : work.role === "subtitle-embedded" && work.ownerId === viewer.id && work.trackIndex === selection.trackIndex &&
+          (work.positions === undefined || work.positions === positions()) &&
+          (work.statement === "subtitle-cues" || work.result === "terminal")));
   }
 
   async bytesChanged(sourceKey, fileIndex) {