@torrent-tv/proxy 2.107.29 → 2.107.30

package/package.json

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

package/server.js

@@ -917,7 +917,7 @@ export async function startProxyServer({
     reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
     changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
-  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand }) => {
+  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand, readPriority }) => {
     const record = sourceRegistry.get(sourceKey);
     if (!record) {
       return null;
@@ -932,6 +932,7 @@ export async function startProxyServer({
       fileIndex,
       requestId,
       packetInterval,
+      readPriority,
       packetMemory: indexMemory.forFile(sourceKey, fileIndex),
       downloadInterval: demand ? { from: demand.from, to: demand.to } : null,
       readRange: (start, end) =>
@@ -1023,7 +1024,7 @@ export async function startProxyServer({
     },
     // `timing`, when given, is told how long each read of a file waited behind
     // the reads asked before it and how long it took (torrent-tv/meta#166).
-    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = null) => {
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = null, readPriority = null) => {
       const grid = output.timeline?.published ?? output.timeline?.boundaries;
       const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
       if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
@@ -1041,7 +1042,7 @@ export async function startProxyServer({
       // reassembled packets otherwise.
       const files = [];
       for (const [fileIndex, choices] of selected) {
-        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
+        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex, readPriority });
         if (!params) return { kind: "needs-source" };
         if (isCurrent) params.isCurrent = isCurrent;
         if (signal) params.signal = signal;

package/services/encode/EncodeInputs.js

@@ -100,7 +100,8 @@ export class EncodeInputs {
     if (request.noted === state) return;
     request.noted = state;
     const serves = request.serves ?? request.from;
-    const rank = this.#rankAt(request.output, serves);
+    const rank = request.readPriority?.serves === serves
+      ? request.readPriority : this.#rankAt(request.output, serves);
     this.#log(`encode input #${request.from}..#${request.to} of ${request.output.outputKey ?? request.output.id}: ${state}` +
       ` (held ${this.held()} of ${this.#allowed} allowed; for #${serves}` +
       `${rank ? `, rank ${rank.rank} of ${rank.topRank}` : ""})${detail}`);
@@ -115,10 +116,10 @@ export class EncodeInputs {
   }
 
   /** The container's statement of an interval, its time added to the request's account. */
-  async #resolveTimed(timing, output, from, to, isCurrent = null, signal = null) {
+  async #resolveTimed(timing, output, from, to, isCurrent = null, signal = null, readPriority = null) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing, isCurrent, signal);
+      return await this.#resolve(output, from, to, timing, isCurrent, signal, readPriority);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -409,6 +410,7 @@ export class EncodeInputs {
   #prepare(request) {
     request.controller ??= new AbortController();
     request.pending = true;
+    request.readPriority = this.#readPriority(request, request.from, request.from);
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
     request.arrivedMeanwhile = null;
@@ -425,7 +427,8 @@ export class EncodeInputs {
       // packet walk, left to run, held the file's reads and the piece the
       // viewer had seeked to waited 16.9 s behind it (r59, torrent-tv/meta#178).
       const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from,
-        () => this.#requests.get(request.key) === request && !request.controller.signal.aborted, request.controller.signal);
+        () => this.#requests.get(request.key) === request && !request.controller.signal.aborted, request.controller.signal,
+        request.readPriority);
       if (resolved.kind === "result") this.#original.set(request.output, resolved.sources?.every(source => source.input.original === true) === true);
       if (this.#requests.get(request.key) !== request) return;
       let result;
@@ -492,6 +495,23 @@ export class EncodeInputs {
     });
   }
 
+  /**
+   * The media reads that prepare one input keep the output map's urgency and
+   * the segment they serve, so a container can run an exact nearby interval
+   * before a speculative attempt to extend that input.
+   *
+   * @param {object} request
+   * @param {number} from
+   * @param {number} to
+   * @returns {{ rank: number, serves: number, from: number, to: number }}
+   */
+  #readPriority(request, from, to) {
+    const serves = request.serves ?? request.from;
+    const rank = this.#rankAt(request.output, serves);
+    return { rank: Number.isFinite(rank?.rank) ? rank.rank : 0, topRank: Number.isFinite(rank?.topRank) ? rank.topRank : 0,
+      serves, from, to };
+  }
+
   /**
    * 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
@@ -563,7 +583,9 @@ export class EncodeInputs {
       if (!stretches.has(end)) {
         // A longer stretch that cannot be stated is not one to copy; the
         // shorter one already stated still runs.
-        const resolved = await this.#resolveTimed(request.timing, output, from, end).catch(() => null);
+        const current = () => this.#requests.get(request.key) === request && !request.controller.signal.aborted;
+        const resolved = await this.#resolveTimed(request.timing, output, from, end, current, request.controller.signal,
+          this.#readPriority(request, from, end)).catch(() => null);
         stretches.set(end, resolved?.kind === "result" && resolved.sources?.every(source => source.input.original === true)
           ? { sources: resolved.sources, bytes: originalInputBytes(resolved.sources) } : null);
       }

package/services/media/ContainerOrchestrator.js

@@ -32,6 +32,28 @@ import { logger } from "../../utils/logger.js";
  */
 export const CONTAINER_HEAD_BYTES = 256 * 1024;
 
+/** Higher urgency, earlier served time, then the smaller source interval. */
+function compareReadPriority(left, right) {
+  const leftRanked = Number.isFinite(left.readPriority?.rank) && left.readPriority.rank > 0;
+  const rightRanked = Number.isFinite(right.readPriority?.rank) && right.readPriority.rank > 0;
+  if (leftRanked !== rightRanked) return rightRanked - leftRanked;
+  if (!leftRanked) return left.sequence - right.sequence;
+  const leftRank = left.readPriority.rank;
+  const rightRank = right.readPriority.rank;
+  if (leftRank !== rightRank) return rightRank - leftRank;
+  const leftServes = Number.isFinite(left.readPriority?.serves) ? left.readPriority.serves : Number.POSITIVE_INFINITY;
+  const rightServes = Number.isFinite(right.readPriority?.serves) ? right.readPriority.serves : Number.POSITIVE_INFINITY;
+  if (leftServes !== rightServes) return leftServes - rightServes;
+  const leftSpan = Number.isFinite(left.readPriority?.from) && Number.isFinite(left.readPriority?.to)
+    ? Math.max(0, left.readPriority.to - left.readPriority.from) : Number.POSITIVE_INFINITY;
+  const rightSpan = Number.isFinite(right.readPriority?.from) && Number.isFinite(right.readPriority?.to)
+    ? Math.max(0, right.readPriority.to - right.readPriority.from) : Number.POSITIVE_INFINITY;
+  if (leftSpan !== rightSpan) return leftSpan - rightSpan;
+  const leftFrom = Number.isFinite(left.readPriority?.from) ? left.readPriority.from : Number.POSITIVE_INFINITY;
+  const rightFrom = Number.isFinite(right.readPriority?.from) ? right.readPriority.from : Number.POSITIVE_INFINITY;
+  return leftFrom - rightFrom || left.sequence - right.sequence;
+}
+
 /**
  * The size of the file and its OpenSubtitles hash, from the two edges. Nothing
  * partial is kept: an edge that has not arrived is named instead.
@@ -101,6 +123,7 @@ export class ContainerOrchestrator {
   #lifetimes = new Map();
   #activityEpoch = 0;
   #activeReads = 0;
+  #readSequence = 0;
 
   activity() { return { epoch: this.#activityEpoch, active: this.#activeReads > 0 }; }
   constructor() {
@@ -147,9 +170,11 @@ export class ContainerOrchestrator {
     let lifetime = this.#lifetimes.get(key);
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
     const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false && params.signal?.aborted !== true;
-    // Reads of one file run one after another, so an answer can wait for every
-    // read asked before it. Told to whoever asked, apart from the read itself,
-    // because the two call for different remedies (torrent-tv/meta#166).
+    // Reads of one file run one after another, ordered by playback-map urgency
+    // and then by interval size, so speculative extensions cannot sit ahead of
+    // an exact interval the viewer needs. Told to whoever asked, apart from
+    // the read itself, because the two call for different remedies
+    // (torrent-tv/meta#166, #ttv-245).
     // A statement answered from what was already read reads and parses
     // nothing, so it is answered beside the queue and holds nobody up: the
     // picture's first input of an AVI waited about 4 s behind the sound's
@@ -159,9 +184,8 @@ export class ContainerOrchestrator {
     // index. Keep it serial with other chapter reads, but out of the queue used
     // to prepare playback inputs for this file.
     const queueKey = statement === "chapters" ? `${key}:chapters` : key;
-    const previous = aside ? Promise.resolve() : this.#reads.get(queueKey) ?? Promise.resolve();
     const askedAt = performance.now();
-    const reading = previous.catch(() => undefined).then(async () => {
+    const perform = async () => {
       if (!isCurrent()) return { result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } };
       const startedAt = performance.now();
       const revision = params.onReadStart?.(statement);
@@ -171,18 +195,70 @@ export class ContainerOrchestrator {
       params.onObserved?.({ statement, askedAt, startedAt, endedAt, queuedMs: startedAt - askedAt,
         readMs: endedAt - startedAt, cached: aside, result: result.kind, reason: result.reason, ranges: result.ranges });
       return { result, revision };
+    };
+    const reading = aside ? Promise.resolve().then(perform) : this.#queueRead(queueKey, { params, isCurrent, perform });
+    const { result, revision } = await reading;
+    if (!isCurrent()) return { kind: "terminal", reason: "request-obsolete", requestId: params.requestId };
+    if (result.kind === "needs-ranges") params.onNeedsRanges?.(result);
+    if (statement === "tracks" && result.kind === "result") params.onTracks?.(result.value);
+    await params.onReadResult?.(statement, result, revision);
+    return result;
+  }
+
+  /** Run one media read at a time per file, in the map's order of urgency. */
+  #queueRead(key, { params, isCurrent, perform }) {
+    let queue = this.#reads.get(key);
+    if (!queue) this.#reads.set(key, queue = { active: false, pending: [] });
+    return new Promise((resolve, reject) => {
+      const entry = { params, isCurrent, perform, resolve, reject, readPriority: params.readPriority,
+        sequence: this.#readSequence++, started: false, abort: null };
+      const cancel = () => {
+        if (entry.started) return;
+        const index = queue.pending.indexOf(entry);
+        if (index < 0) return;
+        queue.pending.splice(index, 1);
+        params.signal?.removeEventListener("abort", entry.abort);
+        resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } });
+        this.#drainReadQueue(key, queue);
+      };
+      entry.abort = cancel;
+      queue.pending.push(entry);
+      queue.pending.sort(compareReadPriority);
+      if (params.signal?.aborted) cancel();
+      else params.signal?.addEventListener("abort", cancel, { once: true });
+      this.#drainReadQueue(key, queue);
     });
-    if (!aside) this.#reads.set(queueKey, reading);
-    try {
-      const { result, revision } = await reading;
-      if (!isCurrent()) return { kind: "terminal", reason: "request-obsolete", requestId: params.requestId };
-      if (result.kind === "needs-ranges") params.onNeedsRanges?.(result);
-      if (statement === "tracks" && result.kind === "result") params.onTracks?.(result.value);
-      await params.onReadResult?.(statement, result, revision);
-      return result;
-    } finally {
-      if (this.#reads.get(queueKey) === reading) this.#reads.delete(queueKey);
+  }
+
+  #drainReadQueue(key, queue) {
+    if (queue.active) return;
+    while (queue.pending.length > 0) {
+      const entry = queue.pending.shift();
+      entry.params.signal?.removeEventListener("abort", entry.abort);
+      if (!entry.isCurrent()) {
+        entry.resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: entry.params.requestId } });
+        continue;
+      }
+      entry.started = true;
+      queue.active = true;
+      Promise.resolve().then(entry.perform).then(entry.resolve, entry.reject).finally(() => {
+        queue.active = false;
+        if (queue.pending.length === 0 && this.#reads.get(key) === queue) this.#reads.delete(key);
+        else this.#drainReadQueue(key, queue);
+      });
+      return;
+    }
+    if (this.#reads.get(key) === queue) this.#reads.delete(key);
+  }
+
+  #cancelQueuedReads(key) {
+    const queue = this.#reads.get(key);
+    if (!queue) return;
+    for (const entry of queue.pending.splice(0)) {
+      entry.params.signal?.removeEventListener("abort", entry.abort);
+      entry.resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: entry.params.requestId } });
     }
+    if (this.#reads.get(key) === queue) this.#reads.delete(key);
   }
 
   /** Whether a statement of this file is answered from what was already read: its track table kept here, or the container's word. */
@@ -380,7 +456,8 @@ export class ContainerOrchestrator {
     for (const key of this.#lifetimes.keys()) {
       if (fileIndex === undefined ? key.startsWith(prefix) : key === `${sourceKey}:${fileIndex}`) {
         this.#lifetimes.delete(key);
-        this.#reads.delete(key);
+        this.#cancelQueuedReads(key);
+        this.#cancelQueuedReads(`${key}:chapters`);
       }
     }
     if (fileIndex === undefined) {