@torrent-tv/proxy 2.96.7 → 2.96.9

package/package.json

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

package/services/media/container/AviContainer.js

@@ -372,6 +372,14 @@ export class AviContainer extends Container {
         const stream = index.packets[track.trackNumber];
         packets.declareTrack(track.trackNumber, { type: "audio", codecId: track.codecId,
           codecRanges: streams[track.trackNumber].codecRanges });
+        // The index says how many packets there are, so the memory they take is
+        // asked for at once. Asked for block by block, a refusal named one
+        // block, the table was discarded and built again for the next one:
+        // field 2026-10-10, 3485 refusals of 64 KB for a two-hour film's
+        // soundtrack, and no soundtrack encoder in three minutes.
+        let count = 0;
+        for (let at = 0; at < stream.count; at++) if (stream.lengths[at]) count++;
+        packets.reservePackets(track.trackNumber, count);
         let previous = -1;
         const append = (end) => {
           packets.append(track.trackNumber, { pts: stream.times[previous], duration: Math.max(0, end - stream.times[previous]),

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);
   }