@torrent-tv/proxy 2.99.17 → 2.99.19

package/package.json

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

package/services/media/container/MatroskaContainer.js

@@ -680,6 +680,26 @@ export class MatroskaContainer extends Container {
     return cues.points.some(point => point.positions.some(position => !video || position.track === video.trackNumber));
   }
 
+  /**
+   * Whether `statement` is answered from what this container has already
+   * read, so it may be answered beside a read of the same file in progress
+   * (`ContainerOrchestrator.inspect`), as an AVI's are. The picture's
+   * ranges are arithmetic over the Cues once they are read; asked behind a
+   * soundtrack's packet walk in the file's one queue, the picture's next
+   * input after a seek was ready only after the sound's, one piece every
+   * 7-8 s, where the two had been prepared side by side every 2 s (r57 against
+   * r50, torrent-tv/meta#178).
+   *
+   * @param {string} statement
+   * @returns {boolean}
+   */
+  answersWithoutReading(statement) {
+    if (statement === "media-info") return this.mediaInfo?.durationSeconds != null;
+    if (statement === "source-navigation") return this.#cues !== undefined && this.#tracks !== null;
+    if (statement === "source-ranges") return this.#sourceSeekPoints !== null;
+    return false;
+  }
+
   async readMappedSourceRanges(interval) { return this.readSourceRanges(interval); }
 
   /**
@@ -834,6 +854,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 +882,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)]));