@torrent-tv/proxy 2.91.0 → 2.92.0

package/services/media/ProbeRequests.js

@@ -0,0 +1,135 @@
+import { IndexMemoryUnavailable } from "./container/memory-unavailable.js";
+
+/** Probes repeat only after the resource they need changes. */
+export class ProbeRequests {
+  #files = new Map();
+  #ids = new Map();
+  #publish;
+  #failed;
+  #next = 0;
+  #listeners = new Map();
+  #memoryRevision = 0;
+
+  constructor({ publish, failed }) {
+    this.#publish = publish;
+    this.#failed = failed;
+  }
+
+  read({ sourceKey, fileIndex, statement, probe }) {
+    const key = `${sourceKey}:${fileIndex}:${statement}`;
+    let request = this.#files.get(key);
+    if (!request) {
+      request = { key, sourceKey, fileIndex, statement, probe, revision: 0, readRevision: -1, result: null, pending: null, ranges: [] };
+      this.#files.set(key, request);
+    }
+    if (request.pending) return request.pending;
+    if (request.result && !["needs-ranges", "needs-memory"].includes(request.result.kind)) return Promise.resolve(request.result);
+    if (request.result?.kind === "needs-memory" ? request.readMemoryRevision === this.#memoryRevision : request.readRevision === request.revision) return Promise.resolve(request.result);
+    return this.#start(request);
+  }
+
+  subscribe(sourceKey, fileIndex, listener) {
+    const key = `${sourceKey}:${fileIndex}`;
+    const listeners = this.#listeners.get(key) ?? new Set();
+    listeners.add(listener);
+    this.#listeners.set(key, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (!listeners.size) this.#listeners.delete(key);
+    };
+  }
+
+  #notify(request, result) {
+    for (const listener of this.#listeners.get(`${request.sourceKey}:${request.fileIndex}`) ?? []) listener(result);
+  }
+
+  withdraw(sourceKey, fileIndex) {
+    for (const [key, request] of this.#files) {
+      if (request.sourceKey !== sourceKey || request.fileIndex !== fileIndex ||
+        (!request.pending && ["result", "terminal"].includes(request.result?.kind))) continue;
+      this.#files.delete(key);
+      request.controller?.abort();
+      this.#notify(request, { kind: "cancelled" });
+    }
+  }
+
+  needs(requestId, start, end) {
+    const request = this.#ids.get(requestId);
+    if (!request) return false;
+    request.ranges.push([start, end]);
+    request.controller.abort();
+    return true;
+  }
+
+  bytesChanged(sourceKey, fileIndex) {
+    for (const request of this.#files.values()) {
+      if (request.sourceKey !== sourceKey || request.fileIndex !== fileIndex) continue;
+      request.revision++;
+      if (!request.pending && request.result?.kind === "needs-ranges") {
+        void this.#start(request).catch(error => this.#failed?.(request, error));
+      }
+    }
+  }
+
+  memoryChanged() {
+    this.#memoryRevision++;
+    for (const request of this.#files.values()) {
+      if (!request.pending && request.result?.kind === "needs-memory") {
+        void this.#start(request).catch(error => this.#failed?.(request, error));
+      }
+    }
+  }
+
+  forget(sourceKey, fileIndex) {
+    for (const [key, request] of this.#files) {
+      if (request.sourceKey !== sourceKey || (fileIndex !== undefined && request.fileIndex !== fileIndex)) continue;
+      this.#files.delete(key);
+      request.controller?.abort();
+      this.#notify(request, { kind: "cancelled", reason: "source-forgotten" });
+    }
+  }
+
+  async #start(request) {
+    const requestId = `${request.key}:${++this.#next}`;
+    request.readRevision = request.revision;
+    request.readMemoryRevision = this.#memoryRevision;
+    request.ranges = [];
+    request.controller = new AbortController();
+    this.#ids.set(requestId, request);
+    const pending = Promise.resolve().then(async () => {
+      let value;
+      try {
+        value = await request.probe({ requestId, signal: request.controller.signal });
+      } catch (error) {
+        if (this.#files.get(request.key) !== request) return { kind: "cancelled", requestId };
+        // Aborting a strict missing-byte read may reject the process promise.
+        // Its ranges remain demand and must be published before retrying.
+        if (error instanceof IndexMemoryUnavailable) {
+          value = { kind: "needs-memory", bytes: error.bytes };
+        } else if (request.ranges.length === 0) {
+          value = { kind: "terminal", reason: "media-probe-failed", message: error?.message ?? String(error) };
+        }
+      }
+      if (this.#files.get(request.key) !== request) return { kind: "cancelled", requestId };
+      request.result = request.ranges.length > 0
+        ? { kind: "needs-ranges", ranges: [...request.ranges], requestId }
+        : ["terminal", "needs-memory"].includes(value?.kind) ? { ...value, requestId } : { kind: "result", value, requestId };
+      await this.#publish({ sourceKey: request.sourceKey, fileIndex: request.fileIndex, statement: request.statement, result: request.result });
+      if (this.#files.get(request.key) === request) this.#notify(request, request.result);
+      return request.result;
+    }).finally(() => {
+      this.#ids.delete(requestId);
+      request.pending = null;
+      const changed = request.result?.kind === "needs-memory"
+        ? this.#memoryRevision !== request.readMemoryRevision
+        : request.result?.kind === "needs-ranges" && request.revision !== request.readRevision;
+      if (this.#files.get(request.key) === request && changed) {
+        queueMicrotask(() => {
+          if (!request.pending) void this.#start(request).catch(error => this.#failed?.(request, error));
+        });
+      }
+    });
+    request.pending = pending;
+    return pending;
+  }
+}

package/services/media/SegmentInputs.js

@@ -0,0 +1,48 @@
+/** The one conversion of a source interval into complete decode input. */
+export class SegmentInputs {
+  #index;
+  #tracks;
+
+  constructor({ index, tracks }) {
+    if (typeof index?.inputFor !== "function" || !Array.isArray(tracks)) {
+      throw new TypeError("Segment input requires a packet index and declared tracks.");
+    }
+    this.#index = index;
+    this.#tracks = tracks;
+  }
+
+  forInterval({ from, to, tracks = this.#tracks, mode = "transcode" }) {
+    const packets = [];
+    const ranges = [];
+    for (const track of tracks) {
+      if (!["audio", "video"].includes(track.type)) continue;
+      const input = this.#index.inputFor({ trackId: track.trackNumber, from, to, mode: typeof mode === "function" ? mode(track) : mode });
+      if (input.kind !== "result") return { ...input, trackId: track.trackNumber };
+      packets.push({ track, ...input });
+      ranges.push(...input.ranges);
+    }
+    if (packets.length === 0) return { kind: "terminal", reason: "source-has-no-media-tracks" };
+    return { kind: "result", from, to, tracks: packets, ranges: unionRanges(ranges) };
+  }
+
+  downloadZones(zones) {
+    const converted = [];
+    for (const zone of zones) {
+      const input = this.forInterval(zone);
+      if (input.kind !== "result") return input;
+      for (const [byteStart, byteEnd] of input.ranges) converted.push({ ...zone, byteStart, byteEnd });
+    }
+    return { kind: "result", zones: converted };
+  }
+}
+
+function unionRanges(ranges) {
+  const ordered = ranges.map(range => [...range]).sort((a, b) => a[0] - b[0]);
+  const result = [];
+  for (const [start, end] of ordered) {
+    const previous = result.at(-1);
+    if (previous && start <= previous[1] + 1) previous[1] = Math.max(previous[1], end);
+    else result.push([start, end]);
+  }
+  return result;
+}

package/services/media/SourceFile.js

@@ -189,6 +189,12 @@ export class SourceFile {
     return sourceDecodeCharacteristics(this.media);
   }
 
+  /** The measured source rate does not require decoded-frame characteristics. */
+  get megabitsPerSecond() {
+    const kbps = Number(this.media?.bitrateKbps);
+    return Number.isFinite(kbps) && kbps > 0 ? kbps / 1000 : null;
+  }
+
   /**
    * The address this proxy's own HTTP serves this file at.
    *

package/services/media/SubtitleOrchestrator.js

@@ -18,11 +18,178 @@
  */
 
 import { logger } from "../../utils/logger.js";
+import { createHash } from "node:crypto";
 import { SubtitleFileContainer } from "./container/SubtitleFileContainer.js";
 import { TextSubtitleTrack } from "./tracks/TextSubtitleTrack.js";
 import { detectLanguage } from "./tracks/language-detect.js";
+import { strictReader, isUnavailable } from "./container/unavailable.js";
 
 export class SubtitleOrchestrator {
+  #documents = new Map();
+  #documentListeners = new Map();
+  #packetCues = new Map();
+
+  /** Decode only the indexed subtitle packets whose bytes are already held. */
+  async inspectPackets(params) {
+    const statement = "subtitle-cues";
+    const revision = params.onReadStart?.(statement);
+    const requestId = params.requestId;
+    let result;
+    try {
+      const container = await this.containers.containerFor(params);
+      const track = (await container.readTracks()).find(track => track.type === "subtitle" && track.declaredIndex === params.subtitleTrackIndex);
+      if (track?.isTextBased?.() !== true) throw new Error("The selected subtitle track is not supported.");
+      const packetResult = typeof this.containers.inspect === "function"
+        ? await this.containers.inspect({ ...params, onReadStart: undefined, onReadResult: undefined,
+          onNeedsRanges: undefined, onTracks: undefined }, "packets")
+        : { kind: "result", value: await container.readPacketIndex(params.packetInterval) };
+      const input = packetResult.kind === "result"
+        ? packetResult.value.inputFor({ trackId: track.trackNumber, ...params.packetInterval }) : packetResult;
+      if (input.kind !== "result") result = { ...input, requestId };
+      else {
+        const key = `${params.sourceKey}:${params.fileIndex}:${track.trackNumber}`;
+        let state = this.#packetCues.get(key);
+        if (!state) {
+          this.#packetCues.set(key, state = { track, packets: new Map(), cursor: 0, ready: false });
+          state.seed = Promise.resolve().then(async () => {
+            const existing = await this.cues.held?.(null, params.fileIndex, params.sourceKey, track.trackNumber);
+            state.cursor = (existing?.cues ?? []).reduce((highest, cue) => Math.max(highest, Number(cue.seq) || 0), 0);
+          }).catch(error => {
+            if (this.#packetCues.get(key) === state) this.#packetCues.delete(key);
+            throw error;
+          });
+        }
+        await state.seed;
+        const read = strictReader(params.readRange, params.fileSize);
+        const pending = [];
+        for (const packet of input.packets) {
+          const identity = JSON.stringify([packet.ranges, packet.pts, packet.duration]);
+          if (state.packets.has(identity)) continue;
+          const portions = [];
+          for (const [from, to] of packet.ranges) portions.push(await read(from, to));
+          const bytes = Buffer.concat(portions);
+          if (packet.expectedHash && createHash("sha256").update(bytes).digest("hex") !== packet.expectedHash) {
+            throw new Error("Subtitle packet bytes do not match the declared source addresses.");
+          }
+          const text = container.cueTextOf(bytes, track.codecId);
+          const cue = { startSeconds: packet.pts,
+            endSeconds: packet.duration > 0 ? packet.pts + packet.duration : null, text };
+          pending.push({ identity, cue });
+        }
+        if (params.isCurrent?.() === false || this.#packetCues.get(key) !== state) {
+          return { kind: "terminal", reason: "request-obsolete", requestId };
+        }
+        state.ready = true;
+        const ordered = () => [...state.packets.values()].sort((first, second) => first.startSeconds - second.startSeconds);
+        const previous = new Map(TextSubtitleTrack.finalizeCues(ordered(), track.codecId).map(cue => [cue.seq, cue]));
+        pending.filter(({ identity }) => !state.packets.has(identity)).forEach(({ identity, cue }) => {
+          const complete = { ...cue, seq: ++state.cursor };
+          state.packets.set(identity, complete);
+        });
+        const withdrawn = [];
+        for (const cue of TextSubtitleTrack.finalizeCues(ordered(), track.codecId)) {
+          const old = previous.get(cue.seq);
+          if (old && old.endSeconds !== cue.endSeconds) {
+            withdrawn.push(cue.seq);
+            const raw = [...state.packets.values()].find(packet => packet.seq === cue.seq);
+            raw.seq = ++state.cursor;
+          }
+        }
+        const fresh = TextSubtitleTrack.finalizeCues(ordered(), track.codecId).filter(cue => !previous.has(cue.seq));
+        if (fresh.length && params.isCurrent?.() !== false) {
+          const cues = fresh;
+          this.cues.publish?.({ sourceKey: params.sourceKey, fileIndex: params.fileIndex,
+            trackIndex: track.declaredIndex, cues, withdrawn, language: track.language ?? "",
+            detectedLanguage: detectLanguage(TextSubtitleTrack.finalizeCues([...state.packets.values()], track.codecId).map(cue => cue.text).join("\n")),
+            cursor: state.cursor, spanStartSeconds: cues[0]?.startSeconds ?? null,
+            spanEndSeconds: cues.at(-1)?.endSeconds ?? null, walkedClusters: 0, indexedClusters: 0 });
+        }
+        result = { kind: "result", value: { cues: [...state.packets.values()], track, coveredClusters: 0, indexedClusters: 0 }, requestId };
+      }
+    } catch (error) {
+      result = isUnavailable(error)
+        ? { kind: "needs-ranges", ranges: [[error.start, error.end]], requestId }
+        : { kind: "terminal", reason: "subtitle-cue-read-failed", message: error?.message ?? String(error), requestId };
+    }
+    await params.onReadResult?.(statement, result, revision);
+    return result;
+  }
+
+  /** Read a text document through the same missing-byte declarations as media. */
+  async inspectFile(params) {
+    const statement = "subtitle-file";
+    const revision = params.onReadStart?.(statement);
+    const key = `${params.sourceKey}:${params.fileIndex}`;
+    const requestId = params.requestId ?? key;
+    let result = this.#documents.get(key);
+    if (result) result = { ...result, requestId };
+    else {
+      try {
+        const extension = String(params.label ?? "").slice(String(params.label ?? "").lastIndexOf(".")).toLowerCase();
+        if (![".srt", ".ass", ".ssa", ".vtt", ".webvtt"].includes(extension)) {
+          result = { kind: "terminal", reason: "subtitle-format-not-supported", requestId };
+        } else if (!Number.isSafeInteger(params.fileSize) || params.fileSize < 0 || params.fileSize > 8 * 1024 * 1024) {
+          result = { kind: "terminal", reason: "subtitle-size-not-supported", requestId };
+        } else {
+          const bytes = await strictReader(params.readRange, params.fileSize)(0, params.fileSize - 1);
+          const value = this.fileAsVtt(bytes, extension);
+          result = value ? { kind: "result", value, requestId }
+            : { kind: "terminal", reason: "subtitle-document-invalid", requestId };
+        }
+      } catch (error) {
+        result = isUnavailable(error)
+          ? { kind: "needs-ranges", ranges: [[error.start, error.end]], requestId }
+          : { kind: "terminal", reason: "subtitle-read-failed", message: error?.message ?? String(error), requestId };
+      }
+      if (params.isCurrent?.() === false) return { kind: "terminal", reason: "request-obsolete", requestId };
+      if (result.kind !== "needs-ranges") {
+        this.#documents.set(key, result);
+        for (const listener of [...(this.#documentListeners.get(key) ?? [])]) listener();
+      }
+    }
+    await params.onReadResult?.(statement, result, revision);
+    return result;
+  }
+
+  documentFor(sourceKey, fileIndex) {
+    return this.#documents.get(`${sourceKey}:${fileIndex}`) ?? null;
+  }
+
+  hasPacketCues(sourceKey, fileIndex, declaredIndex) {
+    const prefix = `${sourceKey}:${fileIndex}:`;
+    return [...this.#packetCues].some(([key, state]) => key.startsWith(prefix) && state.track.declaredIndex === declaredIndex);
+  }
+
+  hasTrackDeclaration(sourceKey, fileIndex) {
+    return this.containers.tracks?.has(`${sourceKey}:${fileIndex}`) === true;
+  }
+
+  /** Subscribe before checking, so publication cannot be missed. */
+  waitForDocument(sourceKey, fileIndex, signal) {
+    const key = `${sourceKey}:${fileIndex}`;
+    return new Promise((resolve, reject) => {
+      let listeners = this.#documentListeners.get(key);
+      if (!listeners) this.#documentListeners.set(key, listeners = new Set());
+      const cleanup = () => {
+        listeners.delete(check);
+        if (!listeners.size) this.#documentListeners.delete(key);
+        signal?.removeEventListener("abort", cancelled);
+      };
+      const cancelled = () => {
+        cleanup();
+        reject(signal?.reason ?? new DOMException("Subtitle request cancelled.", "AbortError"));
+      };
+      const check = () => {
+        const result = this.#documents.get(key);
+        if (!result) return;
+        cleanup();
+        resolve(result);
+      };
+      listeners.add(check);
+      signal?.addEventListener("abort", cancelled, { once: true });
+      if (signal?.aborted) cancelled(); else check();
+    });
+  }
   /**
    * @param {import("./ContainerOrchestrator.js").ContainerOrchestrator} containerOrchestrator
    * @param {object} [cues] - How the torrent reads subtitle cues: `warm`,
@@ -45,6 +212,8 @@ export class SubtitleOrchestrator {
    * @returns {Promise<import("./tracks/index.js").ContainerTrack[]>}
    */
   async getTracks(torrent, fileIndex, sourceKey, readRange, fileSize) {
+    const known = this.containers.tracks?.get(`${sourceKey}:${fileIndex}`);
+    if (Array.isArray(known)) return known.filter(track => track.type === "subtitle");
     try {
       const domain = await this.cues.tracksOf?.(torrent, fileIndex, sourceKey);
       if (Array.isArray(domain) && domain.length > 0) return domain;
@@ -62,6 +231,8 @@ export class SubtitleOrchestrator {
    * Declared subtitle tracks in container order (including image tracks) — for declaredIndex alignment.
    */
   async getDeclaredTracks(torrent, fileIndex, sourceKey) {
+    const known = this.containers.tracks?.get(`${sourceKey}:${fileIndex}`);
+    if (Array.isArray(known)) return known.filter(track => track.type === "subtitle");
     try {
       return (await this.cues.declaredTracksOf?.(torrent, fileIndex, sourceKey)) ?? [];
     } catch {
@@ -86,20 +257,23 @@ export class SubtitleOrchestrator {
    * @returns {Promise<{ cues: object[], coveredClusters: number, indexedClusters: number, track: object | null }>}
    */
   async getCues(torrent, fileIndex, sourceKey, trackNumber) {
-    const empty = () => ({ cues: [], coveredClusters: 0, indexedClusters: 0, track: null });
+    const packets = this.#packetCues.get(`${sourceKey}:${fileIndex}:${trackNumber}`);
+    if (packets) return packets.ready
+      ? { cues: [...packets.packets.values()].sort((first, second) => first.startSeconds - second.startSeconds),
+        track: packets.track, coveredClusters: 0, indexedClusters: 0 } : null;
     if (typeof this.cues.held !== "function") {
       logger.warn(
         "subtitle-orchestrator: no walk was supplied, so no cue can be read — " +
         "an empty document here would be indistinguishable from a file with none"
       );
-      return empty();
+      return null;
     }
     try {
       const answer = await this.cues.held(torrent, fileIndex, sourceKey, trackNumber);
-      return answer ?? empty();
+      return answer?.track ? answer : null;
     } catch (e) {
       logger.warn(`subtitle-orchestrator: getCues failed: ${e?.message ?? e}`);
-      return empty();
+      return null;
     }
   }
 
@@ -161,6 +335,18 @@ export class SubtitleOrchestrator {
   }
 
   forget(sourceKey, fileIndex) {
+    const prefix = fileIndex === undefined ? `${sourceKey}:` : `${sourceKey}:${fileIndex}:`;
+    for (const key of this.#packetCues.keys()) if (key.startsWith(prefix)) this.#packetCues.delete(key);
+    for (const key of this.#documents.keys()) {
+      if (fileIndex === undefined ? key.startsWith(`${sourceKey}:`) : key === `${sourceKey}:${fileIndex}`) this.#documents.delete(key);
+    }
+    for (const [key, listeners] of [...this.#documentListeners]) {
+      if (fileIndex === undefined ? key.startsWith(`${sourceKey}:`) : key === `${sourceKey}:${fileIndex}`) {
+        this.#documents.set(key, { kind: "terminal", reason: "source-forgotten" });
+        for (const listener of [...listeners]) listener();
+        this.#documents.delete(key);
+      }
+    }
     this.cues.forget?.(sourceKey, fileIndex);
     this.containers.forget(sourceKey, fileIndex);
   }

package/services/media/await-plan.js

@@ -0,0 +1,47 @@
+/** Subscribe before checking; pending source declarations have no elapsed deadline. */
+export function waitForPlan({ read, subscribe, signal }) {
+  return new Promise((resolve, reject) => {
+    let done = false, running = false, changed = false, unsubscribe;
+    const finish = (error, value) => {
+      if (done) return;
+      done = true;
+      unsubscribe?.();
+      signal?.removeEventListener("abort", aborted);
+      if (error) reject(error); else resolve(value);
+    };
+    const aborted = () => finish(new DOMException("Playback preparation was cancelled.", "AbortError"));
+    const pump = async () => {
+      if (done || running) return;
+      running = true;
+      try {
+        do {
+          changed = false;
+          const plan = await read();
+          if (!plan.pending) finish(null, plan);
+        } while (changed && !done);
+      } catch (error) { finish(error); }
+      finally {
+        running = false;
+        if (changed && !done) void pump();
+      }
+    };
+    signal?.addEventListener("abort", aborted, { once: true });
+    if (signal?.aborted) { aborted(); return; }
+    try {
+      unsubscribe = subscribe(result => {
+        if (result?.kind === "cancelled") {
+          if (result.reason === "source-forgotten") {
+            const error = new Error("Playback source was forgotten.");
+            error.code = "SOURCE_FORGOTTEN";
+            finish(error);
+          } else aborted();
+          return;
+        }
+        changed = true;
+        void pump();
+      });
+      if (done) unsubscribe?.();
+      else void pump();
+    } catch (error) { finish(error); }
+  });
+}