@torrent-tv/proxy 2.99.19 → 2.99.21

package/package.json

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

package/server.js

@@ -15,6 +15,7 @@ import { handleHealthGet } from "./routes/health/get.js";
 import { handleMediaGet } from "./routes/media/get.js";
 import { ProbeRequests } from "./services/media/ProbeRequests.js";
 import { IndexMemory } from "./services/storage/IndexMemory.js";
+import { LARGEST_GROWTH_BYTES } from "./services/media/container/PacketRecords.js";
 import { probePackets } from "./services/media/probe-packets.js";
 import { trackChoicesOf } from "./services/viewer/segment-demands.js";
 import { PlaybackProjection } from "./services/torrent/PlaybackProjection.js";
@@ -770,6 +771,7 @@ export async function startProxyServer({
     failed: (request, error) => logger.warn(`media request=${request.key} probe failed: ${error?.message ?? error}`)
   });
   const indexMemory = new IndexMemory({
+    growthBytes: LARGEST_GROWTH_BYTES,
     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(); }
   });
@@ -866,7 +868,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) => {
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = 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" };
@@ -912,6 +914,7 @@ export async function startProxyServer({
         if (media.kind !== "result") return media;
         const timeShiftSeconds = Number(media.value?.startTimeSeconds) || 0;
         const sourceInterval = output.timeline.sourceInterval(fromIndex, toIndex, timeShiftSeconds);
+        if (isCurrent) params.isCurrent = isCurrent;
         params.packetInterval = { ...sourceInterval,
           trackIds: wanted.map(track => track.trackNumber),
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };

package/services/encode/EncodeInputs.js

@@ -92,10 +92,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) {
+  async #resolveTimed(timing, output, from, to, isCurrent = null) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing);
+      return await this.#resolve(output, from, to, timing, isCurrent);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -384,7 +384,11 @@ export class EncodeInputs {
       reads: 0, queuedMs: 0, readMs: 0, heldMs: 0, budgetMs: 0 };
     request.timing.attempts += 1;
     request.promise = (async () => {
-      const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from);
+      // A request the plan withdraws stops its reads: a soundtrack piece's
+      // 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);
       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;

package/services/media/ContainerOrchestrator.js

@@ -215,7 +215,8 @@ export class ContainerOrchestrator {
         value = await container.readSourceRanges(params.packetInterval);
         if (value.kind !== "result") return { ...value, requestId };
       } else if (statement === "packets") {
-        value = await container.readPacketIndex(params.packetInterval);
+        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent });
+        if (value === null) return { kind: "terminal", reason: "request-obsolete", requestId };
         await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);
       } else {
         throw new TypeError(`Unknown media statement: ${statement}`);

package/services/media/container/MatroskaContainer.js

@@ -782,7 +782,12 @@ export class MatroskaContainer extends Container {
       streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 
-  async readPacketIndex(interval) {
+  /**
+   * @param {object} [interval]
+   * @param {{ isCurrent?: () => boolean }} [options] - A walk whose request is
+   *   no longer current stops between clusters and answers null.
+   */
+  async readPacketIndex(interval, { isCurrent } = {}) {
     if (this.#packets) return this.#packets;
     const layout = await this.#segmentLayout();
     if (!layout) throw new Error("Matroska Segment is absent.");
@@ -801,7 +806,8 @@ export class MatroskaContainer extends Container {
     const complete = new Set();
     let whole = true;
     for (const track of requested) {
-      const chain = await this.#readTrackPackets(layout, tracks, track, start, interval);
+      const chain = await this.#readTrackPackets(layout, tracks, track, start, interval, isCurrent);
+      if (!chain) return null;
       streams.set(track.trackNumber, chain.records);
       if (chain.reachesEnd) complete.add(track.trackNumber);
       if (!chain.reachesEnd || chain.startAt !== layout.firstClusterAt) whole = false;
@@ -825,7 +831,7 @@ export class MatroskaContainer extends Container {
    *
    * @returns {Promise<{ records: PacketRecordsChain, startAt: number, reachesEnd: boolean }>}
    */
-  async #readTrackPackets(layout, tracks, track, start, interval) {
+  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent) {
     const id = track.trackNumber;
     const previous = this.#packetWalks.get(id) ?? Promise.resolve();
     let finished;
@@ -882,7 +888,8 @@ export class MatroskaContainer extends Container {
         const following = readings.find(reading => reading.startAt > current.startAt);
         const outcome = await walkMatroskaPackets({ readRange: this.readRange, fileSize: this.fileSize,
           portionBytes: this.portionBytes, layout, tracks, trackIds: [id], interval, packetMemory: this.packetMemory,
-          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough });
+          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough, isCurrent });
+        if (outcome === "obsolete") return null;
         if (outcome !== "until") break;
         current.next = following;
       }

package/services/media/container/PacketRecords.js

@@ -9,6 +9,8 @@ const BLOCK_BYTES = 65536;
 // Matroska soundtrack read in stretches: 144 tables of one 25-minute film held
 // 18.9 MB for 3.7 MB of records (r47 reproduced, torrent-tv/meta#178).
 const FIRST_BLOCK_BYTES = 4096;
+/** The most one record can make a table take at once: a block of records and one of addresses. */
+export const LARGEST_GROWTH_BYTES = 2 * BLOCK_BYTES;
 const ADDRESS_BYTES = 8;
 const HEADER_BYTES = 56;
 

package/services/media/container/matroska-packets.js

@@ -44,9 +44,12 @@ function recordedTracks(tracks, trackIds) {
  * `start` on, where the caller knows it: those are read a portion at a time
  * across clusters too.
  *
- * @returns {Promise<"covered" | "until" | "end">}
+ * A walk whose `isCurrent` turns false stops at the next cluster, where its
+ * state is whole, and answers "obsolete".
+ *
+ * @returns {Promise<"covered" | "until" | "end" | "obsolete">}
  */
-export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null }) {
+export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = null, isCurrent = null }) {
   // INSIDE A CLUSTER EVERY BLOCK HEADER IS READ, so its bytes are read a
   // portion at a time up to the cluster's end, and never past it. Read a
   // header at a time, each a read of a few bytes from the torrent thread, the
@@ -71,6 +74,7 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
   if (covered()) return "covered";
   let at = state.at;
   while (at < limit) {
+    if (!state.cluster && isCurrent?.() === false) return "obsolete";
     const element = state.cluster?.element ?? await validHeader(reader, at, layout.segmentEnd);
     if (element.id !== CLUSTER) {
       if (element.end === null) throw new Error("An unknown-sized Matroska element is not a Cluster.");

package/services/storage/IndexMemory.js

@@ -7,18 +7,35 @@ export class IndexMemory {
   #revise;
   #changed;
   #revisionQueued = false;
+  #growthBytes;
 
-  constructor({ reviseBudget, changed }) {
+  /**
+   * @param {object} params
+   * @param {() => void} params.reviseBudget
+   * @param {() => void} params.changed
+   * @param {number} [params.growthBytes] - What one growth of a table can
+   *   take at most, kept free beyond what is held while anything is held. A
+   *   table grows a block at a time, each twice the last; allowed exactly what
+   *   it held, each growth was refused first and its whole read tried again:
+   *   a soundtrack piece after a seek was refused three times and ready after
+   *   53.7 s (r58, torrent-tv/meta#178).
+   */
+  constructor({ reviseBudget, changed, growthBytes = 0 }) {
     this.#revise = reviseBudget;
     this.#changed = changed;
+    this.#growthBytes = growthBytes;
   }
 
   held() { return this.#held; }
   packetBytes() { return this.#packetBytes; }
   wanted() {
+    const short = [...this.#files.values()].reduce((sum, file) => sum + Math.max(0, file.needed - file.held), 0);
+    return this.#held + Math.max(short, this.#held > 0 ? this.#growthBytes : 0);
+  }
+  /** What is held and asked for, without the margin kept for growth. */
+  required() {
     return this.#held + [...this.#files.values()].reduce((sum, file) => sum + Math.max(0, file.needed - file.held), 0);
   }
-  required() { return this.wanted(); }
 
   allow(bytes) {
     const allowed = Math.max(0, bytes);