@torrent-tv/proxy 2.99.13 → 2.99.15

package/package.json

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

package/services/media/container/MatroskaContainer.js

@@ -682,6 +682,18 @@ export class MatroskaContainer extends Container {
 
   async readMappedSourceRanges(interval) { return this.readSourceRanges(interval); }
 
+  /**
+   * The bytes a packet table of `interval` is read from: the clusters the
+   * Cues name for it, as for the original file. Every block header in them is
+   * read, and the headers lie throughout. Null without Cues, where the walk
+   * itself finds what it needs.
+   */
+  async packetWalkRanges(interval) {
+    if (!await this.supportsOriginalSourceRanges()) return null;
+    const ranges = await this.readSourceRanges(interval);
+    return ranges.kind === "result" ? ranges : null;
+  }
+
   async readSourceRanges(interval) {
     if (!Number.isFinite(interval?.from) || !Number.isFinite(interval?.to) || interval.to <= interval.from) {
       throw new TypeError("Source ranges require a finite increasing interval.");

package/services/media/container/ebml-stream.js

@@ -19,6 +19,7 @@
  */
 
 import { readVint } from "./ebml-reader.js";
+import { isUnavailable } from "./unavailable.js";
 
 /** An element id is at most four bytes and a size at most eight (RFC 8794 §4). */
 export const MAX_HEADER_BYTES = 12;
@@ -64,6 +65,10 @@ export class ElementReader {
   /** @type {number} */
   #windowAt = 0;
 
+  /** Below this position a portion was found missing: read exactly there. */
+  #exactBefore = -1;
+  #narrow;
+
   /**
    * @param {object} params
    * @param {(start: number, end: number) => Promise<Buffer>} params.read - Answers
@@ -79,8 +84,13 @@ export class ElementReader {
    *   last byte that can be read from `start` in one go. A read of what is
    *   downloaded must not run a prefetch past the end of the downloaded run,
    *   or a cluster that is whole would fail for the bytes after it.
+   * @param {boolean} [params.narrowWhenMissing] - When a prefetched portion is
+   *   not all downloaded, read only the bytes asked for, and read exactly up to
+   *   the end of that portion: what is not downloaded yet is then only what is
+   *   needed, and the bytes before it are read.
    */
-  constructor({ read, fileSize, portionBytes = Number.POSITIVE_INFINITY, prefetch = false, readableUntil }) {
+  constructor({ read, fileSize, portionBytes = Number.POSITIVE_INFINITY, prefetch = false, readableUntil, narrowWhenMissing = false }) {
+    this.#narrow = narrowWhenMissing;
     this.#read = read;
     this.#fileSize = fileSize;
     this.#readableUntil = typeof readableUntil === "function" ? readableUntil : () => fileSize;
@@ -110,8 +120,15 @@ export class ElementReader {
       return window.subarray(start - this.#windowAt, end - this.#windowAt);
     }
     const reach = Math.min(this.#fileSize, Math.max(end, this.#readableUntil(start)));
-    const span = this.#prefetch ? Math.max(end - start, Math.min(this.#portion, reach - start)) : end - start;
-    const got = await this.#read(start, start + span - 1);
+    const span = this.#prefetch && start >= this.#exactBefore ? Math.max(end - start, Math.min(this.#portion, reach - start)) : end - start;
+    let got;
+    try {
+      got = await this.#read(start, start + span - 1);
+    } catch (error) {
+      if (!this.#narrow || span === end - start || !isUnavailable(error)) throw error;
+      this.#exactBefore = start + span;
+      got = await this.#read(start, end - 1);
+    }
     this.#window = got;
     this.#windowAt = start;
     return got.subarray(0, end - start);

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

@@ -43,7 +43,16 @@ function recordedTracks(tracks, trackIds) {
  * @returns {Promise<"covered" | "until" | "end">}
  */
 export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, trackIds, interval, packetMemory, state, until = null, isCovered = null }) {
-  const reader = new ElementReader({ read: readRange, fileSize, portionBytes });
+  // 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
+  // soundtrack's second piece of a copied 1080p film took 29.6 s on Home
+  // Assistant while that thread was downloading (r52, torrent-tv/meta#178).
+  // Between clusters only their headers are read; where a portion is not all
+  // downloaded, only the bytes a header needs are read and asked for.
+  let readableUntil = null;
+  const reader = new ElementReader({ read: readRange, fileSize, portionBytes, prefetch: true, narrowWhenMissing: true,
+    readableUntil: start => readableUntil ?? start });
   const declared = recordedTracks(tracks, trackIds);
   if (!state.packets) {
     state.packets = new Map([...declared.keys()].map(id => [id, new PacketRecords(packetMemory)]));
@@ -64,6 +73,7 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
     }
     const limit = element.end ?? layout.segmentEnd;
     if (!state.cluster) state.cluster = { element, cursor: element.dataOffset, clusterTicks: null };
+    readableUntil = limit;
     let { cursor, clusterTicks } = state.cluster;
     while (cursor < limit) {
       const child = await validHeader(reader, cursor, limit);
@@ -120,6 +130,7 @@ export async function walkMatroskaPackets({ readRange, fileSize, portionBytes, l
     at = element.end ?? cursor;
     state.at = at;
     state.cluster = null;
+    readableUntil = null;
   }
   if (at < layout.segmentEnd) return "until";
   state.reachedEnd = true;

package/services/media/direct-segment-input.js

@@ -14,7 +14,8 @@
 import { SegmentInputs } from "./SegmentInputs.js";
 
 /**
- * @param {object} container - Has `supportsOriginalSourceRanges`, `readSourceRanges` and `readPacketIndex`.
+ * @param {object} container - Has `supportsOriginalSourceRanges`, `readSourceRanges` and `readPacketIndex`;
+ *   `packetWalkRanges` where a packet table is read from bytes the container can name in advance.
  * @param {{ interval: object, tracks: object[], mode: (track: object) => string }} segment
  * @param {(built: Promise<void>) => void} whenBuilt - Given a promise that settles when a table
  *   still being built is built or refused, when the answer is "pending".
@@ -23,6 +24,14 @@ import { SegmentInputs } from "./SegmentInputs.js";
  */
 export async function directSegmentInput(container, { interval, tracks, mode }, whenBuilt) {
   if (await container.supportsOriginalSourceRanges(interval) === true) return container.readSourceRanges(interval);
+  // A soundtrack read from its own packets is prepared by walking the
+  // clusters that hold them, so those are the bytes it waits for: the map and
+  // the start forecast are told them, as for the picture. Told only the
+  // packets once the walk had found them, a far piece's bytes were unknown
+  // until downloaded, the forecast never stood, and a copied 1080p film did not
+  // start in 275 s (r53, torrent-tv/meta#178).
+  const walked = await container.packetWalkRanges?.(interval);
+  if (walked) return walked;
   // The table is begun, or joined, and not waited for.
   if (container.packetTableWouldWait?.() === true) {
     whenBuilt(container.readPacketIndex(interval).then(() => undefined, () => undefined));