@torrent-tv/proxy 2.98.18 → 2.98.19

package/package.json

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

package/server.js

@@ -65,6 +65,7 @@ import { DownloadMaps } from "./services/viewer/DownloadMaps.js";
 import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/NativeSourceMap.js";
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
+import { directSegmentInput } from "./services/media/direct-segment-input.js";
 import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
 import { pauseCoefficient, viewerStartsOn } from "./services/viewer/PriorityMap.js";
 import { coalescing } from "./utils/coalesce.js";
@@ -551,6 +552,17 @@ export async function startProxyServer({
       `${Math.round(passCosts.ms)}ms from start to result in all, longest ${Math.round(passCosts.maxMs)}ms`);
     Object.assign(passCosts, { since: now, passes: 0, whole: 0, reworked: 0, resolved: 0, windows: 0, ms: 0, maxMs: 0 });
   };
+  // A container whose packet table a pass did not wait for builds the map
+  // again once, when the table is built or refused (`directSegmentInput`).
+  const refreshAfterTable = new WeakSet();
+  const refreshWhenBuilt = (container, built, { sourceKey, fileIndex }) => {
+    if (refreshAfterTable.has(container)) return;
+    refreshAfterTable.add(container);
+    void built.then(() => {
+      refreshAfterTable.delete(container);
+      return downloadMaps.refresh(sourceKey, fileIndex);
+    }).catch(error => logger.warn(`download map after a packet table: ${error?.message ?? error}`));
+  };
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -693,13 +705,15 @@ export async function startProxyServer({
           // packets, which the same index states (torrent-tv/meta#166).
           let 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) });
-            }
+            value = await directSegmentInput(direct, { interval, tracks: wanted, mode: track => modes.get(track) },
+              built => refreshWhenBuilt(direct, built, map));
           } catch { value = null; }
+          // A table still being built holds this output's segments, and only
+          // this output's: the map is built again when it is.
+          if (value?.kind === "pending") {
+            waiting.add(zone.outputKey);
+            continue;
+          }
           // The pass shares the thread in equal turns (`takeTurns`): in one
           // stretch the first pass over a film's 4000 zones held the main thread
           // for all of its work, and handed back after every zone it took

package/services/media/container/AviContainer.js

@@ -199,6 +199,20 @@ export class AviContainer extends Container {
     return false;
   }
 
+  /**
+   * Whether reading the sound's packet table now would wait for it to be
+   * built: the index is read, the table is not, and no refusal of memory for
+   * it stands. A reader with other work may go on with it instead. Field r42
+   * (Home Assistant, 2026-10-14): the download map waited 3.2 s for the
+   * table, between the soundtrack's first segment and the picture's next
+   * ones, and the swarm was asked for the picture's next piece only after it
+   * (torrent-tv/meta#178).
+   */
+  packetTableWouldWait() {
+    if (!this.#index || this.#packets || this.#scan) return false;
+    return this.#soundPacketsRefused === null || this.packetMemory?.fits?.(this.#soundPacketsRefused) !== false;
+  }
+
   /** The index, read from the file; see `#readIndex`. */
   async #readIndexOnce() {
     const tracks = await this.readTracks();

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

@@ -0,0 +1,34 @@
+/**
+ * @file The bytes one segment reads, from an index its container already
+ * holds, for the download map's pass (torrent-tv/meta#178).
+ *
+ * The pass works out every segment of every output a viewer watches, one at a
+ * time. A segment read from the original file is answered by arithmetic over
+ * the index; a soundtrack segment of an AVI needs the sound's packet table,
+ * which is built once for the whole film. While that table was being built the
+ * pass waited for it, and the picture's segments after the soundtrack's first
+ * were not stated to the swarm: field r42 (Home Assistant, 2026-10-14), the
+ * picture's next piece was asked for 4.0 s after its input asked for it, 3.2 s
+ * of that behind the table.
+ */
+import { SegmentInputs } from "./SegmentInputs.js";
+
+/**
+ * @param {object} container - Has `supportsOriginalSourceRanges`, `readSourceRanges` and `readPacketIndex`.
+ * @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".
+ * @returns {Promise<{ kind: string, ranges?: Array<[number, number]> }>} `pending` when the
+ *   answer waits for a table still being built.
+ */
+export async function directSegmentInput(container, { interval, tracks, mode }, whenBuilt) {
+  if (await container.supportsOriginalSourceRanges(interval) === true) return container.readSourceRanges(interval);
+  // The table is begun, or joined, and not waited for.
+  if (container.packetTableWouldWait?.() === true) {
+    whenBuilt(container.readPacketIndex(interval).then(() => undefined, () => undefined));
+    return { kind: "pending" };
+  }
+  const index = await container.readPacketIndex(interval);
+  await index.prepareAudioDependencies?.(interval, container.readRange);
+  return new SegmentInputs({ index, tracks }).forInterval({ ...interval, mode });
+}