@torrent-tv/proxy 2.99.16 → 2.99.18

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -21,6 +21,7 @@ import { computeOutputDimensions } from "./args.js";
 import { buildAdmittedCommand } from "./admitted-command.js";
 import { buildOriginalCommand } from "./source-command.js";
 import { writeAdmittedInput } from "./AdmittedInput.js";
+import { nextPacketInputs } from "./next-packet-input.js";
 import { cutOf, cutShiftOf, judgeNeighbors, judgePiece, leadingSecondsOf, lacksOnlyItsLeadingPictures } from "./piece-completeness.js";
 import { leadingPictures, presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
@@ -1262,23 +1263,23 @@ export class EncodeRuns {
       }
     } else if (admittedInput) {
       run.admittedInputKeys = new Map([[safeIndex, inputKey]]);
-      let nextIndex = startIndex + 1;
+      const nextIndex = startIndex + 1;
       const canAppend = index => this.isLive(session) && run.isAlive &&
         this.#host.encodeOrchestrator.wantedSegmentsOn(session.outputKey).some(window => index >= window.from && index <= window.to) &&
         !this.liveRunsOf(session).some(other => other !== run && index >= other.from && index <= other.to) &&
         !this.#host.producedNumbers(session).includes(index);
+      // Only an input already prepared is appended, and the one after it is
+      // begun at once (`next-packet-input.js`).
+      const following = nextPacketInputs({ take: index => this.#host.encodeInputs.take(session, index, index),
+        canAppend, first: nextIndex, last: ordered?.to ?? startIndex });
       void writeAdmittedInput(admittedInput, run.process.stdin, { next: async () => {
-        if (nextIndex > (ordered?.to ?? startIndex) || !canAppend(nextIndex)) return null;
-        const next = await this.#host.encodeInputs.acquire(session, nextIndex, nextIndex);
-        if (!next) return null;
-        if (!canAppend(nextIndex)) { next.release(); return null; }
-        run.admittedInputKeys.set(nextIndex, this.#inputFailures.key(next, inputParameters));
-        run.to = nextIndex++;
+        const next = following.next(index => { run.to = index; });
+        if (next) run.admittedInputKeys.set(run.to, this.#inputFailures.key(next, inputParameters));
         return next;
-      }, waiting: waits => { if (waits) run.inputWaitBegins(); else run.inputWaitEnds(); } }).catch(error => {
+      } }).catch(error => {
         this.#host.logger.warn(`encode input output=${session.outputKey} segment=${safeIndex} write failed: ${error.message}`);
         run.process?.stdin?.destroy();
-      });
+      }).finally(() => following.release());
     }
     this.#runsByInputToken.set(inputToken, run);
     this.#host.encodersChanged?.();

package/services/encode/next-packet-input.js

@@ -0,0 +1,56 @@
+/**
+ * @file Which input a run fed packet by packet goes on with.
+ *
+ * Such a run keeps its input open while more is appended, and FFmpeg closes a
+ * piece only once it reads past the piece's end, so a piece is published when
+ * the input after it arrives or the input ends. Waited for, the next input
+ * held each piece back for as long as preparing it took: on Home Assistant a
+ * soundtrack's #7 waited 14 s for #8's attempt, which ended refused memory, and
+ * the picture stood at 61.8 s (r54, r55, torrent-tv/meta#178).
+ *
+ * So a run is given the next input only when it is ready, and the one after it
+ * is begun as soon as one is taken: the run goes on while preparation keeps
+ * ahead of it, and ends, publishing its last piece, when it does not. The plan
+ * starts the next run on the input being prepared.
+ */
+
+/**
+ * A source of the inputs after a run's first.
+ *
+ * @param {object} params
+ * @param {(index: number) => object | null} params.take - The input of one
+ *   piece if ready, beginning its preparation otherwise (`EncodeInputs.take`).
+ * @param {(index: number) => boolean} params.canAppend - Whether the piece may
+ *   still be made by this run.
+ * @param {number} params.first - The first piece after the run's own.
+ * @param {number} params.last - The last piece the run may reach.
+ * @returns {{ next: (onTaken?: (index: number) => void) => object | null, release: () => void }}
+ */
+export function nextPacketInputs({ take, canAppend, first, last }) {
+  let index = first;
+  let ahead = null;
+  const begin = at => {
+    if (at <= last && canAppend(at)) ahead = take(at);
+  };
+  begin(index);
+  return {
+    next(onTaken) {
+      if (index > last || !canAppend(index)) return null;
+      const input = ahead ?? take(index);
+      ahead = null;
+      if (!input) return null;
+      if (!canAppend(index)) {
+        input.release();
+        return null;
+      }
+      onTaken?.(index);
+      index += 1;
+      begin(index);
+      return input;
+    },
+    release() {
+      ahead?.release();
+      ahead = null;
+    }
+  };
+}

package/services/media/container/MatroskaContainer.js

@@ -834,6 +834,17 @@ export class MatroskaContainer extends Container {
       const declared = new Map([[id, track]]);
       const asked = interval ? { ...interval, trackIds: [id] } : null;
       const depth = track.type === "video" ? track.reorderDepth : 0;
+      // WHERE THE WALK WILL READ, as the Cues name it (`packetWalkRanges`):
+      // read a portion at a time across cluster boundaries too. Read a
+      // cluster's header and its contents apart, a soundtrack piece took
+      // about sixteen reads of the torrent thread, each waiting for its loop
+      // (0.5-0.8 s late on Home Assistant), and 7-12 s to prepare with every
+      // byte held (r56, torrent-tv/meta#178).
+      const walked = interval ? await this.packetWalkRanges(interval) : null;
+      const readsThrough = walked ? start => {
+        const range = walked.ranges.find(([from, to]) => from <= start && start <= to);
+        return range ? range[1] + 1 : null;
+      } : null;
       let current = null;
       const covered = () => {
         if (!asked) return false;
@@ -851,7 +862,7 @@ 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 });
+          state: current, until: following?.startAt ?? null, isCovered: covered, readsThrough });
         if (outcome !== "until") break;
         current.next = following;
       }

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

@@ -40,9 +40,13 @@ function recordedTracks(tracks, trackIds) {
  * Only the named tracks are recorded: a soundtrack read on its own kept the
  * picture's table as well, half of 37.9 MB on r47's order (torrent-tv/meta#178).
  *
+ * `readsThrough(start)` is one past the last byte the walk will read from
+ * `start` on, where the caller knows it: those are read a portion at a time
+ * across clusters too.
+ *
  * @returns {Promise<"covered" | "until" | "end">}
  */
-export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null }) {
+export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null, readsThrough = 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
@@ -55,7 +59,7 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
   // Between clusters only their headers are read.
   let readableUntil = null;
   const reader = new ElementReader({ read: readRange, fileSize, portionBytes, prefetch: true,
-    readableUntil: start => readableUntil ?? start });
+    readableUntil: start => Math.max(readableUntil ?? start, readsThrough?.(start) ?? start) });
   const declared = recordedTracks(tracks, trackIds);
   if (!state.packets) {
     state.packets = new Map([...declared.keys()].map(id => [id, new PacketRecords(packetMemory)]));