@torrent-tv/proxy 2.107.28 → 2.107.29

package/package.json

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

package/server.js

@@ -1023,7 +1023,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) => {
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = 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" };
@@ -1043,6 +1043,8 @@ export async function startProxyServer({
       for (const [fileIndex, choices] of selected) {
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         if (!params) return { kind: "needs-source" };
+        if (isCurrent) params.isCurrent = isCurrent;
+        if (signal) params.signal = signal;
         if (timing) {
           params.walkAccount = timing.walk ??= { lockMs: 0, reads: 0, bytes: 0 };
           params.onTimed = (statement, waitedMs, readMs) => {
@@ -1073,7 +1075,6 @@ 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

@@ -115,10 +115,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) {
+  async #resolveTimed(timing, output, from, to, isCurrent = null, signal = null) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing, isCurrent);
+      return await this.#resolve(output, from, to, timing, isCurrent, signal);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -208,6 +208,7 @@ export class EncodeInputs {
         : "withdrawn: no wanted window covers it");
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       request.result?.release?.();
     }
     this.#retryMemory();
@@ -233,6 +234,7 @@ export class EncodeInputs {
       this.#note(request, "withdrawn: the plan places no run there");
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       // A copy already answered may still be copying its stretch; released,
       // the stretch is dropped when its read returns.
       request.result?.release?.();
@@ -335,6 +337,7 @@ export class EncodeInputs {
       if (request.output !== output) continue;
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       request.result?.release?.();
     }
     this.#shared.forget(output);
@@ -404,6 +407,7 @@ export class EncodeInputs {
   }
 
   #prepare(request) {
+    request.controller ??= new AbortController();
     request.pending = true;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
@@ -421,7 +425,7 @@ 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);
+        () => this.#requests.get(request.key) === request && !request.controller.signal.aborted, request.controller.signal);
       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

@@ -146,7 +146,7 @@ export class ContainerOrchestrator {
     const key = `${params.sourceKey}:${params.fileIndex}`;
     let lifetime = this.#lifetimes.get(key);
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
-    const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false;
+    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).
@@ -237,9 +237,10 @@ 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, { isCurrent: params.isCurrent, account: params.walkAccount });
+        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent, signal: params.signal, account: params.walkAccount });
         if (value === null) return { kind: "terminal", reason: "request-obsolete", requestId };
-        await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);
+        const readRange = (start, end) => container.readRange(start, end, { signal: params.signal });
+        await value?.prepareAudioDependencies?.(params.packetInterval, readRange);
       } else if (statement === "chapters") {
         value = await container.readChapters({ read: params.readHeld ?? params.readRange,
           isCurrent: params.isCurrent,
@@ -252,7 +253,7 @@ export class ContainerOrchestrator {
       }
       return { kind: "result", value, requestId };
     } catch (error) {
-      if (statement === "chapters" && params.isCurrent?.() === false) return { kind: "terminal", reason: "request-obsolete", requestId };
+      if (params.isCurrent?.() === false) return { kind: "terminal", reason: "request-obsolete", requestId };
       if (error instanceof ChapterUnsupported) return { kind: "terminal", reason: "chapter-not-supported", chapterReason: error.message, requestId };
       if (error instanceof IndexMemoryUnavailable) {
         const result = { kind: "needs-memory", bytes: error.bytes, requestId };

package/services/media/container/AsfContainer.js

@@ -42,11 +42,11 @@ export class AsfContainer extends Container {
   }
   static detect(head) { return head.length >= 16 && head.subarray(0, 16).toString("hex") === HEADER; }
 
-  async #readHeader() {
+  async #readHeader(readRange = this.readRange) {
     if (this.#info) return;
     this.#declarations ??= new RetainedReads(this.packetMemory);
     if (!this.#header) {
-      const bytes = await this.readRange(0, 29);
+      const bytes = await readRange(0, 29);
       if (!AsfContainer.detect(bytes) || bytes[28] !== 1 || bytes[29] !== 2) throw new Error("ASF header is invalid.");
       const size = Number(bytes.readBigUInt64LE(16));
       const count = bytes.readUInt32LE(24);
@@ -56,7 +56,7 @@ export class AsfContainer extends Container {
       this.#header = { size, count };
     }
     while (this.#objects.length < this.#header.count) {
-      const head = await this.readRange(this.#offset, this.#offset + 23);
+      const head = await readRange(this.#offset, this.#offset + 23);
       const size = Number(head.readBigUInt64LE(16));
       if (!Number.isSafeInteger(size) || size < 24 || this.#offset + size > this.#header.size) {
         throw new Error("ASF child object exceeds its header.");
@@ -64,7 +64,7 @@ export class AsfContainer extends Container {
       const guid = head.subarray(0, 16).toString("hex");
       if (ENCRYPTION.has(guid)) throw new Error("ASF media is encrypted.");
       const bytes = [FILE, STREAM, EXTENSION, EXTENDED_STREAM, LANGUAGES].includes(guid)
-        ? await this.#declarations.read(this.#offset + 24, this.#offset + size - 1, this.readRange) : null;
+        ? await this.#declarations.read(this.#offset + 24, this.#offset + size - 1, readRange) : null;
       this.#objects.push({ guid, bytes });
       this.#offset += size;
     }
@@ -212,18 +212,19 @@ export class AsfContainer extends Container {
     const index = await this.readPacketIndex();
     return { times: index.keyframesOf(track.trackNumber), tolerance: 0 };
   }
-  async readPacketIndex(interval, { isCurrent } = {}) {
+  async readPacketIndex(interval, { isCurrent, signal } = {}) {
+    const readRange = signal ? (start, end) => this.readRange(start, end, { signal }) : this.readRange;
     if (isCurrent?.() === false) return null;
-    await this.#readHeader();
+    await this.#readHeader(readRange);
     if (isCurrent?.() === false) return null;
     if (!this.#packets && Number.isFinite(interval?.from) && Number.isFinite(interval?.to) && interval.to > interval.from) {
-      const window = await this.#readWindow(interval, isCurrent);
+      const window = await this.#readWindow(interval, isCurrent, readRange);
       if (isCurrent?.() === false) return null;
       if (window) return window;
     }
     if (isCurrent?.() === false) return null;
     if (!this.#packets) {
-      const index = await readAsfPackets({ readRange: this.readRange, fileSize: this.fileSize, tracks: this.#tracks,
+      const index = await readAsfPackets({ readRange, fileSize: this.fileSize, tracks: this.#tracks,
         info: { ...this.#info, durationSeconds: this.#duration }, state: this.#packetState, packetMemory: this.packetMemory, isCurrent });
       if (index === null) return null;
       const timeline = this.#tracks.find(track => track.type === "video") ?? this.#tracks.find(track => track.type === "audio");
@@ -251,8 +252,8 @@ export class AsfContainer extends Container {
    * interval, is read again from twice as far back, and from the first packet
    * at the latest; which it reaches is checked on what it read, not assumed.
    */
-  async #readWindow(interval, isCurrent) {
-    const data = await this.#dataLayout();
+  async #readWindow(interval, isCurrent, readRange = this.readRange) {
+    const data = await this.#dataLayout(readRange);
     if (isCurrent?.() === false) return null;
     if (!data) return null;
     const requested = this.#tracks.filter(track => ["video", "audio"].includes(track.type) &&
@@ -262,9 +263,9 @@ export class AsfContainer extends Container {
     for (let lead = this.#info.prerollSeconds + WINDOW_LEAD_SECONDS; ; lead *= 2) {
       if (isCurrent?.() === false) return null;
       const sentFrom = interval.from - lead;
-      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent);
+      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent, readRange);
       if (isCurrent?.() === false) return null;
-      const window = await readAsfWindow({ readRange: this.readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom, isCurrent });
+      const window = await readAsfWindow({ readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom, isCurrent });
       if (isCurrent?.() === false) return null;
       if (window.startCovered || first === 0) return window.index;
     }
@@ -275,9 +276,9 @@ export class AsfContainer extends Container {
    * the format requires it (the File Properties state one length as both the
    * least and the most), and a packet is then found by its number.
    */
-  async #dataLayout() {
+  async #dataLayout(readRange = this.readRange) {
     if (this.#data === null) {
-      const data = await readAsfData({ readRange: this.readRange, fileSize: this.fileSize, info: this.#info });
+      const data = await readAsfData({ readRange, fileSize: this.fileSize, info: this.#info });
       const length = this.#info.packetLength;
       const fixed = length > 0 && this.#info.minimumPacketLength === length;
       const whole = fixed ? Math.floor((data.end - data.start) / length) : 0;
@@ -300,16 +301,16 @@ export class AsfContainer extends Container {
    * bytes the window from it to `until` is estimated to take, so the swarm is
    * asked for the packet and the window it begins at once.
    */
-  async #packetSentBefore(seconds, data, until, isCurrent) {
+  async #packetSentBefore(seconds, data, until, isCurrent, readRange = this.readRange) {
     if (isCurrent?.() === false) return null;
-    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data, 1, isCurrent), highSent = this.#duration;
+    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data, 1, isCurrent, readRange), highSent = this.#duration;
     if (isCurrent?.() === false) return null;
     if (lowSent > seconds) return 0;
     // Past the last packet nothing is sent before the film ends; the last
     // packet itself is read only when the search needs it.
     if (!(highSent > seconds)) {
       high = data.count - 1;
-      highSent = await this.#sentAt(high, data, 1, isCurrent);
+      highSent = await this.#sentAt(high, data, 1, isCurrent, readRange);
       if (highSent <= seconds) return high;
     }
     for (const [number, at] of this.#sent) {
@@ -324,7 +325,7 @@ export class AsfContainer extends Container {
       const guess = guesses >= 3 || !(perSecond > 0) ? Math.floor((low + high) / 2) : low + Math.floor((aim - lowSent) * perSecond);
       const probe = Math.min(high - 1, Math.max(low + 1, guess));
       const window = perSecond > 0 ? Math.ceil((until - aim) * perSecond) : 1;
-      const at = await this.#sentAt(probe, data, Math.max(1, window), isCurrent);
+      const at = await this.#sentAt(probe, data, Math.max(1, window), isCurrent, readRange);
       if (isCurrent?.() === false) return null;
       if (at <= seconds) { low = probe; lowSent = at; }
       else { high = probe; highSent = at; }
@@ -336,12 +337,12 @@ export class AsfContainer extends Container {
    * When packet `number` is sent. A packet that is not held is said as
    * missing with the `packets` packets from it.
    */
-  async #sentAt(number, data, packets = 1, isCurrent) {
+  async #sentAt(number, data, packets = 1, isCurrent, readRange = this.readRange) {
     if (isCurrent?.() === false) return null;
     if (!this.#sent.has(number)) {
       const at = data.start + number * data.length;
       try {
-        this.#sent.set(number, await readAsfPacketTime({ readRange: this.readRange, at, end: data.end, info: this.#info }));
+        this.#sent.set(number, await readAsfPacketTime({ readRange, at, end: data.end, info: this.#info }));
       } catch (error) {
         if (!isUnavailable(error) || packets <= 1) throw error;
         throw new BytesUnavailable(at, Math.min(data.start + data.count * data.length, at + packets * data.length) - 1, 0);

package/services/media/container/Container.js

@@ -54,7 +54,7 @@ export class Container {
    * the medium — a torrent's piece length. Absent, an element is read in one go.
    *
    * @param {object} params
-   * @param {(start:number,end:number)=>Promise<Buffer|null>} [params.readRange]
+   * @param {(start:number,end:number,options?:{signal?:AbortSignal})=>Promise<Buffer|null>} [params.readRange]
    * @param {number} [params.fileSize]
    * @param {string} [params.label]
    * @param {number} [params.portionBytes]

package/services/media/container/unavailable.js

@@ -56,17 +56,37 @@ export function isUnavailable(error) {
  * the clamped range is a read that did not finish: a stream that ended early,
  * a piece that is not downloaded, a store that could not serve it.
  *
- * @param {(start: number, end: number) => Promise<Buffer | null>} read
+ * @param {(start: number, end: number, options?: { signal?: AbortSignal }) => Promise<Buffer | null>} read
  * @param {number} fileSize
- * @returns {(start: number, end: number) => Promise<Buffer>}
+ * @returns {(start: number, end: number, options?: { signal?: AbortSignal }) => Promise<Buffer>}
  */
 export function strictReader(read, fileSize) {
-  return async (start, end) => {
+  return async (start, end, { signal } = {}) => {
     const last = Math.min(end, fileSize - 1);
     if (!(start >= 0) || last < start) {
       return Buffer.alloc(0);
     }
-    const bytes = await read(start, last);
+    let bytes;
+    if (!signal) {
+      bytes = await read(start, last);
+    } else {
+      const abort = () => {
+        const error = new Error("Read cancelled.");
+        error.name = "AbortError";
+        return error;
+      };
+      if (signal.aborted) throw abort();
+      let onAbort;
+      const cancelled = new Promise((_, reject) => {
+        onAbort = () => reject(abort());
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      try {
+        bytes = await Promise.race([read(start, last, { signal }), cancelled]);
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
     const wanted = last - start + 1;
     const received = bytes ? bytes.length : 0;
     if (received < wanted) {