@torrent-tv/proxy 2.96.6 → 2.96.7

package/package.json

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

package/server.js

@@ -495,9 +495,17 @@ export async function startProxyServer({
         const known = segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
         if (direct) {
+          // Asked per zone too: a soundtrack of an AVI is read from its own
+          // packets, which the same index states (torrent-tv/meta#166).
           let value = null;
-          try { value = await direct.readSourceRanges(interval); }
-          catch { value = null; }
+          try {
+            if (await direct.supportsOriginalSourceRanges(interval) === true) value = await direct.readSourceRanges(interval);
+            else {
+              const index = await direct.readPacketIndex(interval);
+              await index.prepareAudioDependencies?.(interval, direct.readRange);
+              value = new SegmentInputs({ index, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
+            }
+          } catch { value = null; }
           if (!map.isCurrent()) return [];
           if (value?.kind === "result") {
             segmentSourceRanges.set(rangesKey, value.ranges);

package/services/media/ContainerOrchestrator.js

@@ -198,7 +198,7 @@ export class ContainerOrchestrator {
         value = await (statement === "cover" ? container.readCover(edgesOf(params)) : container.readWorkTags(edgesOf(params)));
         if (value === null) return { kind: "terminal", reason: statement === "cover" ? "no-cover" : "format-states-nothing", requestId };
       } else if (statement === "source-navigation") {
-        value = await container.supportsOriginalSourceRanges?.() === true;
+        value = await container.supportsOriginalSourceRanges?.(params.packetInterval ?? null) === true;
       } else if (statement === "source-ranges") {
         if (typeof container.readSourceRanges !== "function") return { kind: "terminal", reason: "source-range-index-not-supported", requestId };
         value = await container.readSourceRanges(params.packetInterval);

package/services/media/container/AviContainer.js

@@ -32,6 +32,8 @@ export class AviContainer extends Container {
   #headers = null;
   #tracks = null;
   #packets = null;
+  /** The sound packets of an indexed file while they are being stated, so two asks build them once. */
+  #soundPacketsReading = null;
   #scan = null;
   #declarations = null;
   #workTags = null;
@@ -150,10 +152,18 @@ export class AviContainer extends Container {
     return index;
   }
 
-  async supportsOriginalSourceRanges() {
+  /**
+   * Whether `interval` is read from the original file. Only a picture needs
+   * it: an AVI states no presentation time, so FFmpeg's own reading is what
+   * keeps its frames in order. Sound alone is read from its own packets, whose
+   * time the index states (torrent-tv/meta#166); asked of the file as a whole,
+   * the answer is the picture's.
+   */
+  async supportsOriginalSourceRanges(interval = null) {
     const index = await this.#readIndex();
     if (!index) return false;
     const picture = ContainerTrack.firstUsable(await this.readTracks(), "video");
+    if (picture && interval?.trackIds?.length && !interval.trackIds.includes(picture.trackNumber)) return false;
     return !picture || index.keyframeTimes(picture.trackNumber).length > 0;
   }
 
@@ -312,9 +322,19 @@ export class AviContainer extends Container {
   async readPacketIndex(interval) {
     if (this.#packets) return this.#packets;
     if (this.#scan) return this.#readUnindexed(interval);
-    // A file with an index is read by FFmpeg from the original bytes; packets
-    // are reassembled only where no index states them (torrent-tv/meta#151).
-    if (await this.#readIndex()) throw new Error("AVI with an index is read from the original file, not from reassembled packets.");
+    // A picture of a file with an index is read by FFmpeg from the original
+    // bytes (torrent-tv/meta#151). Its SOUND is not: the index states every
+    // sound packet's place and FFmpeg's time for it, and a soundtrack read from
+    // the original file has to carry the picture's bytes too, because sound and
+    // picture are interleaved — field 2026-10-10, a two-hour film's soundtrack
+    // copied 2.3 GB for 0.19 GB of its own (torrent-tv/meta#166).
+    const indexed = await this.#readIndex();
+    if (indexed) {
+      this.#soundPacketsReading ??= this.#soundPacketsOf(indexed).then(
+        packets => (this.#packets = packets),
+        error => { this.#soundPacketsReading = null; throw error; });
+      return this.#soundPacketsReading;
+    }
     const tracks = await this.readTracks();
     const { streams } = await this.#readHeaders();
     const index = new PacketIndex({ packetMemory: this.packetMemory, deferMemory: true });
@@ -333,6 +353,45 @@ export class AviContainer extends Container {
     return this.#readUnindexed(interval);
   }
 
+  /**
+   * The sound packets an AVI index states, on FFmpeg's clock: the time the
+   * index gives each packet is the one FFmpeg's demuxer gives it, and a packet
+   * lasts until the next one of its stream, the last until the stream's clock
+   * after it. Only sound is declared; a picture of an indexed AVI states no
+   * presentation time and is read from the original file.
+   *
+   * @param {{ packets: Array<{ count: number, starts: Float64Array, lengths: Uint32Array, times: Float64Array, end: number | null }> }} index
+   * @returns {Promise<PacketIndex>}
+   */
+  async #soundPacketsOf(index) {
+    const tracks = await this.readTracks();
+    const { streams } = await this.#readHeaders();
+    const packets = new PacketIndex({ packetMemory: this.packetMemory });
+    try {
+      for (const track of tracks.filter(one => one.type === "audio")) {
+        const stream = index.packets[track.trackNumber];
+        packets.declareTrack(track.trackNumber, { type: "audio", codecId: track.codecId,
+          codecRanges: streams[track.trackNumber].codecRanges });
+        let previous = -1;
+        const append = (end) => {
+          packets.append(track.trackNumber, { pts: stream.times[previous], duration: Math.max(0, end - stream.times[previous]),
+            keyframe: true, ranges: [[stream.starts[previous], stream.starts[previous] + stream.lengths[previous] - 1]] });
+        };
+        for (let at = 0; at < stream.count; at++) {
+          if (!stream.lengths[at]) continue;
+          if (previous >= 0) append(stream.times[at]);
+          previous = at;
+        }
+        if (previous >= 0) append(stream.end ?? stream.times[previous]);
+        packets.complete(track.trackNumber);
+      }
+    } catch (error) {
+      packets.dispose();
+      throw error;
+    }
+    return packets;
+  }
+
   async #readUnindexed(interval) {
     const state = this.#scan;
     state.index.flushPending();

package/services/media/container/avi-index.js

@@ -44,6 +44,8 @@ class StreamPackets {
     this.lengths = new Uint32Array(count);
     this.times = new Float64Array(count);
     this.keyframes = new Uint8Array(count);
+    /** Where the stream's clock stands after its last packet: the last packet's end. */
+    this.end = null;
   }
 
   push(start, length, time, keyframe) {
@@ -186,6 +188,7 @@ async function readIdx1({ read, fileSize, movi, idx1, streams, allocation }) {
         clocks[id].advance(length);
       }
     }
+    packets.forEach((stream, id) => { stream.end = clocks[id].seconds(); });
     return new AviIndex({ packets, indexRanges: [[idx1.start - 8, fileSize - 1]], held, allocation });
   } catch (error) {
     allocation?.release?.(held);
@@ -247,6 +250,7 @@ async function readOpenDml({ read, fileSize, streams, allocation }) {
         }
       }
     }
+    packets.forEach((stream, id) => { stream.end = clocks[id].seconds(); });
     return new AviIndex({ packets, indexRanges: parsed.map(standard => [standard.start, standard.end - 1]), held, allocation });
   } catch (error) {
     allocation?.release?.(held);