@torrent-tv/proxy 2.99.20 → 2.99.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.99.20",
+  "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

@@ -868,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" };
@@ -914,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/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.");