@torrent-tv/proxy 2.94.0 → 2.94.2

package/package.json

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

package/services/media/container/AviContainer.js

@@ -102,7 +102,7 @@ export class AviContainer extends Container {
       if (!(error instanceof OutsideReadableEdges)) throw error;
       tags.outsideEdges = true;
     }
-    tags.trackTitles = textList((await this.readTracks()).map((track) => track.name));
+    tags.trackTitles = await this.trackTitlesForWork();
     if (!tags.outsideEdges) this.#workTags = tags;
     return tags;
   }

package/services/media/container/Container.js

@@ -12,7 +12,8 @@
  *  - AVI RIFF §: LIST hdrl, idx1
  */
 
-import { strictReader } from "./unavailable.js";
+import { isUnavailable, strictReader } from "./unavailable.js";
+import { textList } from "./work-tags.js";
 
 /**
  * What one file declares about itself. Every field is either a value the
@@ -514,6 +515,23 @@ export class Container {
     return null;
   }
 
+  /**
+   * The titles of the file's tracks, for what it states about its work. A
+   * track table this program refuses to read costs only the titles: the
+   * statements about the work are read from other elements. Bytes that have
+   * not arrived are still "not here yet".
+   *
+   * @returns {Promise<string[]>}
+   */
+  async trackTitlesForWork() {
+    try {
+      return textList((await this.readTracks()).map((track) => track.name));
+    } catch (error) {
+      if (isUnavailable(error)) throw error;
+      return [];
+    }
+  }
+
   /**
    * The cover image the file carries, checked to be an image by its bytes.
    * `null` where it carries none.

package/services/media/container/MatroskaContainer.js

@@ -437,7 +437,7 @@ export class MatroskaContainer extends Container {
       const cover = await this.#coverAddress(reader, layout);
       if (cover && cover.size > 0 && cover.size <= MAX_COVER_BYTES) tags.cover = { type: cover.mediaType, size: cover.size };
     } catch (error) { leftOut(error); }
-    tags.trackTitles = textList((await this.readTracks()).map((track) => track.name));
+    tags.trackTitles = await this.trackTitlesForWork();
     if (!tags.outsideEdges) this.#workTags = tags;
     return tags;
   }

package/services/media/container/Mp4Container.js

@@ -28,7 +28,7 @@ import { hevcConfiguration } from "./hevc-configuration.js";
 import { mpegAudioFrame } from "./mpeg-audio-frame.js";
 import { readMp4Fragments } from "./mp4-fragments.js";
 import { workFromMoov } from "./mp4-work-tags.js";
-import { COVER_TYPES, MAX_COVER_BYTES, emptyWorkTags, imageTypeOf, textList } from "./work-tags.js";
+import { COVER_TYPES, MAX_COVER_BYTES, emptyWorkTags, imageTypeOf } from "./work-tags.js";
 
 /** A box header is eight bytes, or sixteen when the size field says 1 (§4.2). */
 const HEADER_BYTES = 8;
@@ -532,7 +532,7 @@ export class Mp4Container extends Container {
       Object.assign(tags, work);
       if (cover && cover.size > 0 && cover.size <= MAX_COVER_BYTES) tags.cover = { type: cover.type, size: cover.size };
     }
-    tags.trackTitles = textList((await this.readTracks()).map((track) => track.name));
+    tags.trackTitles = await this.trackTitlesForWork();
     this.workTags = tags;
     return tags;
   }

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) {