@torrent-tv/proxy 2.96.8 → 2.96.10

package/package.json

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

package/server.js

@@ -54,6 +54,7 @@ import { wireOutputs } from "./services/server/wire-outputs.js";
 import { createPlaybackPlanner } from "./services/media/playback-planner.js";
 import { KeyframeTables } from "./services/media/KeyframeTables.js";
 import { contentsOf } from "./services/torrent/Contents.js";
+import { joinedWithinPieces } from "./services/torrent/demand/pieces.js";
 import { SubtitleOrchestrator } from "./services/media/SubtitleOrchestrator.js";
 import { containerOrchestrator, CONTAINER_HEAD_BYTES, describeWorkTags } from "./services/media/ContainerOrchestrator.js";
 import { readPlaybackDeclarations } from "./services/media/read-playback-declarations.js";
@@ -434,6 +435,9 @@ export async function startProxyServer({
       const media = await containerOrchestrator.inspect(params, "media-info");
       if (media.kind !== "result" || !map.isCurrent()) return [];
       const shift = Number(media.value?.startTimeSeconds) || 0;
+      // A zone's ranges are stated to the torrent at the precision it fetches:
+      // ranges closer than a piece hold the same pieces as one.
+      const pieceLength = Number(torrentPool.knownTorrent(map.sourceKey)?.pieceLength);
       const converted = [];
       const demands = [];
       for (const output of outputParts.outputs.values()) {
@@ -483,7 +487,7 @@ export async function startProxyServer({
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
         const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         const convert = ranges => {
-          for (const [byteStart, byteEnd] of ranges) converted.push({ ...demand,
+          for (const [byteStart, byteEnd] of joinedWithinPieces(ranges, pieceLength)) converted.push({ ...demand,
             downloadInterval: { from: zone.owner.from, to: zone.owner.to }, byteStart, byteEnd });
         };
         // The bytes one segment needs are a fact of the file and the output, so

package/services/media/container/PacketIndex.js

@@ -72,7 +72,13 @@ export class PacketIndex {
       if (track.type !== "audio" || !isMp3Codec(track.codecId) ||
           (interval?.trackIds && !interval.trackIds.includes(id)) || interval?.modes?.[id] === "copy") continue;
       const records = track.packets;
-      for (let position = 0; position < records.length; position++) {
+      // As in inputFor: records in time order are searched rather than read
+      // in full; one that starts too early to reach the interval is skipped
+      // below unless a record its preroll frames ahead does reach it.
+      const ordered = interval && records.ptsAscending;
+      const scanFrom = ordered ? Math.max(0, records.firstAtOrAfter(interval.from - records.longestDuration) - track.prerollFrames) : 0;
+      const scanTo = ordered ? records.firstAtOrAfter(interval.to) : records.length;
+      for (let position = scanFrom; position < scanTo; position++) {
         const packet = records.at(position);
         if (!packet.decodeDependencyUnknown || (interval &&
             (packet.pts >= interval.to || (packet.pts < interval.from && packet.pts + packet.duration <= interval.from &&
@@ -174,7 +180,15 @@ export class PacketIndex {
     const packets = track.packets;
     const startAt = from - (track.type === "audio" && mode === "transcode" ? track.prerollSeconds : 0);
     const selected = [];
-    for (let index = 0; index < packets.length; index++) {
+    // Records in time order are searched: only one starting within the
+    // longest duration before the interval can reach into it. Read in full,
+    // a two-hour soundtrack is 340 thousand records per interval, and the
+    // download map asked for two thousand intervals at once: the proxy's main
+    // thread stopped for minutes (Home Assistant 2026-10-10, torrent-tv/meta#166).
+    const ordered = packets.ptsAscending;
+    const scanFrom = ordered ? packets.firstAtOrAfter(startAt - packets.longestDuration) : 0;
+    const scanTo = ordered ? packets.firstAtOrAfter(to) : packets.length;
+    for (let index = scanFrom; index < scanTo; index++) {
       const pts = packets.ptsAt(index);
       if (pts < to && (pts >= startAt ||
         ((mode === "transcode" || track.type === "audio") && pts + packets.durationAt(index) > startAt))) selected.push(index);

package/services/media/container/PacketRecords.js

@@ -17,6 +17,12 @@ export class PacketRecords {
   #onDispose;
   #disposed = false;
   #prepaid = 0;
+  // Where the records first go back in time (-1 while they never do), the last
+  // time pushed, and the longest duration any record has had: what lets a
+  // reader find an interval by search instead of reading every record.
+  #descentAt = -1;
+  #lastPts = -Infinity;
+  #longest = 0;
 
   constructor(memory = {}) {
     const allocation = memory.forRecord?.(this) ?? memory;
@@ -77,9 +83,30 @@ export class PacketRecords {
       this.#bytes = [...this.#blocks, ...this.#addresses].reduce((sum, buffer) => sum + buffer.length, 0);
     }
     this.#length = value;
+    if (this.#descentAt >= value) this.#descentAt = -1;
+    this.#lastPts = value ? this.ptsAt(value - 1) : -Infinity;
+    if (!value) this.#longest = 0;
     if (previousBytes !== this.#bytes) this.#release(previousBytes - this.#bytes);
   }
 
+  /** Whether every record's time is at least the one before it. */
+  get ptsAscending() { return this.#descentAt < 0; }
+
+  /** No record has lasted longer than this, though a removed one may have: a bound, not a measurement. */
+  get longestDuration() { return this.#longest; }
+
+  /** The first record whose time is at least `seconds`, `length` when there is none; only when the times ascend. */
+  firstAtOrAfter(seconds) {
+    if (!this.ptsAscending) throw new Error("Records whose times go back cannot be searched by time.");
+    let low = 0, high = this.#length;
+    while (low < high) {
+      const middle = (low + high) >>> 1;
+      if (this.ptsAt(middle) < seconds) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  }
+
   push(packet) {
     if (this.#disposed) throw new Error("Packet records were released.");
     if (!Number.isFinite(packet.pts) || !Array.isArray(packet.ranges) ||
@@ -137,6 +164,9 @@ export class PacketRecords {
     if (packet.streamId !== undefined) block.writeUInt32LE(packet.streamId, at + bytes - 4 - (packet.decodeFromIndex !== undefined ? 4 : 0));
     if (packet.decodeFromIndex !== undefined) block.writeUInt32LE(packet.decodeFromIndex, at + bytes - 4);
     this.#used += bytes;
+    if (this.#descentAt < 0 && packet.pts < this.#lastPts) this.#descentAt = this.#length;
+    this.#lastPts = packet.pts;
+    if (packet.duration > this.#longest) this.#longest = packet.duration;
     return ++this.#length;
   }
 
@@ -204,7 +234,9 @@ export class PacketRecords {
   extendLastPresentation(seconds) {
     if (!this.#length) return;
     const [block, at] = this.#address(this.#length - 1);
-    block.writeDoubleLE(block.readDoubleLE(at + 8) + seconds, at + 8);
+    const duration = block.readDoubleLE(at + 8) + seconds;
+    block.writeDoubleLE(duration, at + 8);
+    if (duration > this.#longest) this.#longest = duration;
   }
 
   setDuration(index, seconds, derived = false) {
@@ -213,6 +245,7 @@ export class PacketRecords {
     }
     const [block, at] = this.#address(index);
     block.writeDoubleLE(seconds, at + 8);
+    if (seconds > this.#longest) this.#longest = seconds;
     const flags = block.readUInt32LE(at + 48);
     block.writeUInt32LE(derived ? flags | 4 : flags & ~4, at + 48);
   }

package/services/torrent/demand/pieces.js

@@ -106,3 +106,29 @@ export function nearestFirst({ byteStart, byteEnd, parts }) {
   }
   return ranges;
 }
+
+/**
+ * Byte ranges joined wherever the gap between two of them is shorter than a
+ * piece: the pieces they hold are the same, and there are fewer of them.
+ *
+ * A gap shorter than a piece cannot hold a whole piece, so every piece it
+ * touches is touched by a range beside it. The soundtrack of an AVI read from
+ * its own packets is one range per packet, interleaved with the picture's
+ * bytes: field 2026-10-10 (torrent-tv/meta#166), a map of 350 191 zones took
+ * 20.8 s to reach the torrent thread and grew its heap to 818 MB, for pieces of
+ * 4 MiB that the whole soundtrack touches anyway.
+ *
+ * @param {Array<[number, number]>} ranges - Inclusive byte ranges in ascending order.
+ * @param {number} pieceLength
+ * @returns {Array<[number, number]>} The same ranges when the piece length is not usable.
+ */
+export function joinedWithinPieces(ranges, pieceLength) {
+  if (!Number.isFinite(pieceLength) || pieceLength <= 0) return ranges;
+  const joined = [];
+  for (const [start, end] of ranges) {
+    const previous = joined.at(-1);
+    if (previous && start >= previous[0] && start - previous[1] - 1 < pieceLength) previous[1] = Math.max(previous[1], end);
+    else joined.push([start, end]);
+  }
+  return joined;
+}