@torrent-tv/proxy 2.96.5 → 2.96.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.96.5",
+  "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

@@ -422,6 +422,7 @@ export async function startProxyServer({
   const segmentSourceRanges = new Map();
   const downloadMaps = new DownloadMaps({
     publish: (map) => torrentPool.setPriorityMap(map),
+    log: (line) => logger.info(line),
     resolvePlayback: async (map) => {
       if (map.zones.length === 0) return [];
       const params = await containerOver(map);
@@ -494,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);

package/services/torrent/worker/client.js

@@ -476,7 +476,7 @@ export class TorrentWorkerClient {
    * @returns {Promise<void>}
    */
   async setPriorityMap({ sourceKey, fileIndex, zones, durationSeconds }) {
-    await this.#caller.call(Command.PRIORITY_MAP, {
+    return this.#caller.call(Command.PRIORITY_MAP, {
       sourceKey,
       fileIndex,
       zones,

package/services/torrent/worker/pool-adapter.js

@@ -168,7 +168,7 @@ export class WorkerTorrentPool {
     if (!sourceKey) {
       return;
     }
-    await this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones });
+    return this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones });
   }
 
   /**

package/services/torrent/worker/worker.js

@@ -459,12 +459,17 @@ async function runCommand(command, params, id) {
       const zones = Array.isArray(params.zones) ? params.zones : [];
       // Nor may one for a file held whole, which has nothing left to fetch.
       const torrent = await knownTorrent(params.sourceKey);
-      if (torrent) {
-        ensureArrivalsWired(params.sourceKey, torrent);
-        pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
-        torrent.emit("priority-map-changed", params.fileIndex);
+      if (!torrent) {
+        return { appliedMs: null };
       }
-      return true;
+      // What applying a map costs this thread, told to whoever sent it: every
+      // zone becomes a window of the register and the swarm is told again
+      // (torrent-tv/meta#166).
+      const startedAt = performance.now();
+      ensureArrivalsWired(params.sourceKey, torrent);
+      pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
+      torrent.emit("priority-map-changed", params.fileIndex);
+      return { appliedMs: performance.now() - startedAt };
     }
 
     case Command.READ_RANGE: {

package/services/viewer/DownloadMaps.js

@@ -1,14 +1,24 @@
+/**
+ * How often what the publications of one file cost is said, at most: the
+ * cadence of the proxy's other once-a-minute readings.
+ */
+const REPORT_EVERY_MS = 60_000;
+
 /** One published download map per file, including download-only metadata reads. */
 export class DownloadMaps {
   #files = new Map();
   #publish;
   #resolvePlayback;
   #nextEpoch = 0;
+  #log;
+  #now;
 
-  constructor({ publish, resolvePlayback = async map => map.zones }) {
+  constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
+    this.#log = typeof log === "function" ? log : null;
+    this.#now = now;
   }
 
   async playback({ sourceKey, fileIndex, durationSeconds, zones }) {
@@ -197,11 +207,130 @@ export class DownloadMaps {
       }
     }
     const publication = { sourceKey: file.sourceKey, fileIndex: file.fileIndex, durationSeconds: file.durationSeconds, zones };
+    // SENT ONLY WHEN THE TORRENT WOULD ACT ON IT DIFFERENTLY: other bytes,
+    // another level or order of claim, or deadlines in another order. A map was
+    // sent after every read of the file's statements, changed or not, and the
+    // read waited for it: field 2026-10-10, 48-64 such reads per stretch of a
+    // two-hour AVI, 28-54 s before its copy began, with 5-12 thousand zones in
+    // each map (torrent-tv/meta#166). A deadline worked out again on a later
+    // clock moves every zone of a viewer playing on by the same amount and
+    // orders nothing differently, so the deadlines' order is compared and not
+    // their values.
+    const shape = shapeOf(publication);
+    if (file.shape && sameShape(file.shape, shape)) {
+      this.#statsOf(file).unchanged += 1;
+      this.#report(file);
+      return Promise.resolve();
+    }
+    file.shape = shape;
     const pending = file.pending.then(() => {
-      if (this.#files.get(`${file.sourceKey}:${file.fileIndex}`) === file) return this.#publish(publication);
+      if (this.#files.get(`${file.sourceKey}:${file.fileIndex}`) !== file) return undefined;
+      const sentAt = this.#now();
+      return Promise.resolve(this.#publish(publication)).then(reply => {
+        // A torrent not yet in the thread applies nothing, so this map was not
+        // delivered and the next one, however alike, has to be.
+        if (reply?.appliedMs === null && file.shape === shape) file.shape = null;
+        // The window open now, which a report since this map was asked for may have started.
+        const stats = this.#statsOf(file);
+        stats.sent += 1;
+        stats.zones.push(zones.length);
+        stats.deliveredMs.push(this.#now() - sentAt);
+        if (Number.isFinite(reply?.appliedMs)) stats.appliedMs.push(reply.appliedMs);
+        this.#report(file);
+        return reply;
+      });
+    });
+    // A failed publication must not prevent the next state change from being
+    // sent, and leaves nothing to compare the next one against.
+    file.pending = pending.catch(() => {
+      if (file.shape === shape) file.shape = null;
     });
-    // A failed publication must not prevent the next state change from being sent.
-    file.pending = pending.catch(() => undefined);
     return pending;
   }
+
+  #statsOf(file) {
+    file.stats ??= { since: this.#now(), sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+    return file.stats;
+  }
+
+  /** What this file's publications cost, said once a minute at most and only when one was asked for. */
+  #report(file) {
+    const stats = file.stats;
+    const now = this.#now();
+    if (!this.#log || !stats || now - stats.since < REPORT_EVERY_MS) return;
+    const total = values => Math.round(values.reduce((sum, value) => sum + value, 0));
+    this.#log(`download map ${file.sourceKey.slice(0, 48)}:${file.fileIndex}: ${stats.sent} sent and ` +
+      `${stats.unchanged} unchanged not sent in ${((now - stats.since) / 1000).toFixed(1)}s; ` +
+      `zones median ${middle(stats.zones)} max ${largest(stats.zones)}; ` +
+      `delivered median ${middle(stats.deliveredMs)}ms max ${largest(stats.deliveredMs)}ms (${total(stats.deliveredMs)}ms in all), ` +
+      `applied in the torrent thread median ${middle(stats.appliedMs)}ms max ${largest(stats.appliedMs)}ms ` +
+      `(${total(stats.appliedMs)}ms in all)`);
+    file.stats = { since: now, sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+  }
+}
+
+/** How many numbers describe one zone's part in what the torrent does. */
+const ZONE_FIELDS = 7;
+
+/** @param {boolean | undefined} value */
+function flag(value) {
+  return value === true ? 2 : value === false ? 1 : 0;
+}
+
+/** @param {{ deadlineAt?: number }} zone */
+function deadlineOf(zone) {
+  return Number.isFinite(zone.deadlineAt) ? zone.deadlineAt : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * What the torrent acts on in a publication, packed for comparison: each
+ * zone's bytes, priority, words of level, order of claim, and the RANK of its
+ * deadline among the map's zones rather than the deadline itself. A zone with
+ * no deadline carries the time it is wanted within, which the torrent turns
+ * into a deadline on its own clock when the map is applied.
+ *
+ * @param {{ durationSeconds: number, zones: object[] }} publication
+ * @returns {{ durationSeconds: number, fields: Float64Array }}
+ */
+function shapeOf({ durationSeconds, zones }) {
+  const byDeadline = zones.map((_zone, index) => index).sort((left, right) => {
+    const first = deadlineOf(zones[left]);
+    const second = deadlineOf(zones[right]);
+    return first === second ? left - right : first < second ? -1 : 1;
+  });
+  const fields = new Float64Array(zones.length * ZONE_FIELDS);
+  byDeadline.forEach((index, rank) => {
+    fields[index * ZONE_FIELDS + 5] = rank;
+  });
+  zones.forEach((zone, index) => {
+    const at = index * ZONE_FIELDS;
+    fields[at] = Number.isFinite(zone.byteStart) ? zone.byteStart : -1;
+    fields[at + 1] = Number.isFinite(zone.byteEnd) ? zone.byteEnd : -1;
+    fields[at + 2] = Number.isFinite(zone.priority) ? zone.priority : -1;
+    fields[at + 3] = flag(zone.urgent) * 27 + flag(zone.deferred) * 9 + flag(zone.behind) * 3 + flag(zone.downloadOnly);
+    fields[at + 4] = Number.isSafeInteger(zone.order) ? zone.order : 0;
+    fields[at + 6] = Number.isFinite(zone.deadlineAt) ? -2 : Number.isFinite(zone.withinSeconds) ? zone.withinSeconds : -1;
+  });
+  return { durationSeconds: Number.isFinite(durationSeconds) ? durationSeconds : -1, fields };
+}
+
+/** @param {{ durationSeconds: number, fields: Float64Array }} left @param {{ durationSeconds: number, fields: Float64Array }} right */
+function sameShape(left, right) {
+  if (left.durationSeconds !== right.durationSeconds || left.fields.length !== right.fields.length) return false;
+  for (let index = 0; index < left.fields.length; index++) {
+    if (left.fields[index] !== right.fields[index]) return false;
+  }
+  return true;
+}
+
+/** @param {number[]} values */
+function middle(values) {
+  if (values.length === 0) return "n/a";
+  const sorted = [...values].sort((left, right) => left - right);
+  return Math.round(sorted[Math.floor(sorted.length / 2)]);
+}
+
+/** @param {number[]} values */
+function largest(values) {
+  return values.length === 0 ? "n/a" : Math.round(Math.max(...values));
 }