@torrent-tv/proxy 2.95.22 → 2.95.24

package/package.json

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

package/routes/encode-input/get.js

@@ -1,7 +1,7 @@
 import { parseRange } from "../../utils/parse-range.js";
 
 /** FFmpeg reads only original byte ranges already owned by its live run. */
-export function handleEncodeInputGet(req, reply, { inputOf }) {
+export function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }) {
   const address = req.raw?.socket?.remoteAddress;
   if (!["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(address)) return reply.code(403).send();
   const token = Number(req.params.token), fileIndex = Number(req.params.fileIndex);
@@ -26,7 +26,12 @@ export function handleEncodeInputGet(req, reply, { inputOf }) {
   // end of a content range). A cap of 1 MiB here ended every original-source
   // segment longer than that on 6.1 (torrent-tv/meta#151).
   const held = input.read(fileIndex, range.start, range.end, true);
-  if (!held) return reply.code(503).send({ error: "Original input bytes are outside the admitted ranges." });
+  if (!held) {
+    // FFmpeg asked for a byte the run was not given: the container named too
+    // little. Said, because FFmpeg itself reports only a failed seek or read.
+    refused({ token, fileIndex, start: range.start, runTag: input.runTag ?? null });
+    return reply.code(503).send({ error: "Original input bytes are outside the admitted ranges." });
+  }
   return reply.code(206).header("Content-Length", String(held.bytes.length))
     .header("Content-Range", `bytes ${range.start}-${held.end}/${length}`).send(held.bytes);
 }

package/server.js

@@ -1147,7 +1147,8 @@ export async function startProxyServer({
     })
   );
   app.get("/encode-input/:token/:fileIndex", (req, reply) =>
-    handleEncodeInputGet(req, reply, { inputOf: token => outputParts.encodeRuns.originalInputOf(token) })
+    handleEncodeInputGet(req, reply, { inputOf: token => outputParts.encodeRuns.originalInputOf(token),
+      refused: ({ fileIndex, start, runTag }) => logger.warn(`encode input: run ${runTag ?? "?"} asked for byte ${start} of file ${fileIndex}, which it was not given`) })
   );
   app.get("/stream", async (req, reply) =>
     handleStreamGet(req, reply, {

package/services/encode/EncodePlan.js

@@ -794,13 +794,24 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
   const lateAt = new Map(ranks.map((rank) => [rank, 0]));
   /** When the last number of a rank is made, per rank. @type {Map<number, number>} */
   const doneAt = new Map(ranks.map((rank) => [rank, 0]));
+  // How many numbers each encoder has already passed over that are made, kept
+  // as the walk goes rather than counted again for every number: counted again,
+  // a film of two thousand pieces cost the plan four million steps, and the
+  // plan held the proxy's thread for most of every second (Home Assistant
+  // 2026-10-08, torrent-tv/meta#151). The same count `madeBetween` gives.
+  const passed = encoders.map((encoder) => coverage.madeBetween(encoder.at, first - 1));
   for (let index = first; index <= last; index += 1) {
+    const readyHere = coverage.isReady(index);
+    for (let at = 0; at < encoders.length; at += 1) {
+      if (readyHere && encoders[at].at <= index) passed[at] += 1;
+    }
     // Which encoder gets to this piece first, and when. One standing on it is
     // already there; one behind it must work its way up, re-making anything
     // already made on the way, which costs its own time and the swarm's.
     let soonest = Number.POSITIVE_INFINITY;
     let byWhom = null;
-    for (const encoder of encoders) {
+    for (let at = 0; at < encoders.length; at += 1) {
+      const encoder = encoders[at];
       if (encoder.at > index) {
         continue;
       }
@@ -820,13 +831,13 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
       // stood still for 116.7 s.
       const arrival = encoder.delaySec
         + (index - encoder.at) / rate
-        + coverage.madeBetween(encoder.at, index) * refetchSecPerSegment;
+        + passed[at] * refetchSecPerSegment;
       if (arrival < soonest) {
         soonest = arrival;
         byWhom = encoder;
       }
     }
-    if (coverage.isReady(index)) {
+    if (readyHere) {
       // It exists. Nobody waits for it and nothing is owed — but whoever passes
       // over it makes it a second time, and the swarm fetches its bytes again.
       if (byWhom !== null) {
@@ -1103,8 +1114,19 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
     // the map happens to be in.
     let best = null;
     let bestDue = Number.POSITIVE_INFINITY;
+    // Where every encoder already placed stands, and how many made numbers lie
+    // between it and the number the walk is on — kept as the walk goes, because
+    // counted again for every number a two-hour film made this one walk
+    // millions of steps, and the plan held the proxy's thread for most of every
+    // second (Home Assistant 2026-10-08, torrent-tv/meta#151).
+    const standing = [...placed.map((live) => live.at), ...(alsoPlaced ?? [])];
+    const passed = standing.map((a) => coverage.madeBetween(a, start - 1));
     for (let index = start; index <= last; index += 1) {
-      if (coverage.isReady(index)) {
+      const readyHere = coverage.isReady(index);
+      for (let which = 0; which < standing.length; which += 1) {
+        if (readyHere && standing[which] <= index) passed[which] += 1;
+      }
+      if (readyHere) {
         continue;
       }
       const deadline = deadlineAt(index);
@@ -1121,7 +1143,8 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
       // second and a third on the very next numbers — three processes a segment
       // apart for one person, which is the waste this model exists to refuse.
       let soonest = Number.POSITIVE_INFINITY;
-      for (const a of [...placed.map((live) => live.at), ...(alsoPlaced ?? [])]) {
+      for (let which = 0; which < standing.length; which += 1) {
+        const a = standing[which];
         if (a > index) {
           // Standing past it. Encoders only move forward, so it never will.
           continue;
@@ -1141,7 +1164,7 @@ function gapFinderFor(coverage, surviving, rate, refetchSecPerSegment = 0) {
         // to arrive, and the model compares arrivals. Asked separately it was a
         // second authority over the same encoder, and the two disagreed.
         const arrival = (index - a + 1) / rate
-          + coverage.madeBetween(a, index) * refetchSecPerSegment;
+          + passed[which] * refetchSecPerSegment;
         if (arrival < soonest) {
           soonest = arrival;
         }

package/services/encode/EncodeRun.js

@@ -478,7 +478,9 @@ export class EncodeRun {
       if (line.length > 0) {
         this.lastError = line;
         const errorText = this.#stderrReadTail + String(chunk);
-        this.#inputTruncated ||= /Stream ends prematurely|Input\/output error|Error during demuxing/i.test(errorText);
+        // A failed seek leaves the demuxer wherever it stood, so what follows is
+        // not the stretch asked for and is never published (torrent-tv/meta#151).
+        this.#inputTruncated ||= /Stream ends prematurely|Input\/output error|Error during demuxing|Seek failed/i.test(errorText);
         this.#stderrReadTail = errorText.slice(-512);
         this.logger.warn(`ffmpeg #${this.from}..#${this.to} of ${this.address}: ${line}`);
       }

package/services/media/container/AviContainer.js

@@ -142,8 +142,9 @@ export class AviContainer extends Container {
     const record = { dispose: () => this.#index?.dispose?.() };
     const allocation = this.packetMemory?.forRecord?.(record, "index") ?? this.packetMemory;
     const index = await readAviIndex({ read: this.readRange, fileSize: this.fileSize, movi, idx1, allocation,
-      streams: tracks.map(track => ({ type: track.type, timeBase: track.timeBase, sampleSize: track.sampleSize,
-        startTimeSeconds: track.startTimeSeconds, indexChunks: streams[track.trackNumber].indexChunks })) });
+      streams: tracks.map(track => ({ type: track.type, codecId: track.codecId, timeBase: track.timeBase,
+        sampleSize: track.sampleSize, blockAlign: track.blockAlign ?? 0, startUnits: track.startUnits ?? 0,
+        indexChunks: streams[track.trackNumber].indexChunks })) });
     this.#index = index;
     return index;
   }
@@ -173,8 +174,12 @@ export class AviContainer extends Container {
     if (!index) return { kind: "needs-index", reason: "source-has-no-avi-index" };
     const tracks = await this.readTracks();
     const { movi } = await this.#topLevel();
-    const requested = tracks.filter(track => ["video", "audio"].includes(track.type) &&
-      (!interval.trackIds?.length || interval.trackIds.includes(track.trackNumber)));
+    // Every audio and video stream, whichever the run outputs: FFmpeg's AVI
+    // demuxer seeks to the earliest position any stream's index gives for the
+    // keyframe time (`pos_min`, avi_read_seek) and reads every stream's packets
+    // in file order. Naming only the run's own tracks left a picture-only run
+    // asking for sound it was not given, and its seek failed (torrent-tv/meta#151).
+    const requested = tracks.filter(track => ["video", "audio"].includes(track.type));
     const picture = ContainerTrack.firstUsable(tracks, "video");
     const padded = ([start, end]) => [Math.max(0, start), Math.min(this.fileSize - 1, end + FFMPEG_INPUT_BUFFER_BYTES)];
     const ranges = [[0, movi.start + 3], ...index.indexRanges, ...index.firstPackets(),
@@ -230,6 +235,7 @@ export class AviContainer extends Container {
         track = new AudioTrack({ ...params, codecId: waveCodec(tag),
           channels: strf.readUInt16LE(2), samplingFrequency: strf.readUInt32LE(4),
           codecPrivateB64: strf.subarray(18).toString("base64") });
+        track.blockAlign = strf.readUInt16LE(12);
         track.matroskaCodecId = "A_MS/ACM";
         track.matroskaCodecPrivateB64 = (strf.length === 16
           ? Buffer.concat([strf, Buffer.alloc(2)]) : strf).toString("base64");
@@ -238,6 +244,7 @@ export class AviContainer extends Container {
       track.startTimeSeconds = track.timeBase === null ? null : strh.readUInt32LE(28) * track.timeBase;
       track.durationSeconds = track.timeBase === null ? null : strh.readUInt32LE(32) * track.timeBase;
       track.sampleSize = strh.readUInt32LE(44);
+      track.startUnits = strh.readUInt32LE(28);
       if (["h264", "hevc"].includes(track.codecId)) track.presentationCadenceSeconds = track.timeBase;
       return track;
     });

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

@@ -74,8 +74,9 @@ class StreamPackets {
  * @param {number} params.fileSize
  * @param {{ start: number, end: number }} params.movi - The first `movi` list (`start` at its type).
  * @param {{ start: number, end: number } | null} params.idx1 - The `idx1` chunk's payload, if any.
- * @param {Array<{ type: string, timeBase: number | null, sampleSize: number, startTimeSeconds: number | null,
- *   indexChunks: Array<{ start: number, end: number }> }>} params.streams - In stream-number order.
+ * @param {Array<{ type: string, codecId: string, timeBase: number | null, sampleSize: number, blockAlign: number,
+ *   startUnits: number, indexChunks: Array<{ start: number, end: number }> }>} params.streams - In stream-number order,
+ *   as the stream headers declare them (`strh` sample size and start, `WAVEFORMATEX` block alignment).
  * @param {{ reserve?: (bytes: number) => boolean, release?: (bytes: number) => void }} params.allocation
  * @returns {Promise<AviIndex | null>} Null when the file states no index.
  */
@@ -104,8 +105,38 @@ function reserve(allocation, count) {
   return bytes;
 }
 
-function durationOf(stream, length) {
-  return stream.timeBase * (stream.sampleSize > 0 ? length / stream.sampleSize : 1);
+/**
+ * A stream's clock as FFmpeg's AVI demuxer keeps it (avidec.c n8.1). The clock
+ * counts units: bytes where the stream has a sample size, otherwise blocks of
+ * the audio's `nBlockAlign` rounded up per packet (`get_duration`), otherwise
+ * one per packet, an empty one included. A packet's time is its units, divided
+ * by the sample size where there is one, times the time base. FFmpeg's header
+ * rules decide the sample size and the block alignment it uses; they are taken
+ * over exactly, since a time that disagrees with FFmpeg's moves the bytes a
+ * seek asks for out of the ranges named (field 2026-10-08: a two-hour MP3 AVI
+ * failed to seek at 384 s).
+ */
+function clockOf(stream) {
+  // The header's sample size is a signed 32-bit field to FFmpeg; the start is
+  // multiplied by it as read, before any correction, and a start beyond an hour
+  // is discarded.
+  const declared = (stream.sampleSize ?? 0) | 0;
+  const startUnits = (stream.startUnits ?? 0) * stream.timeBase > 3600 ? 0 : stream.startUnits ?? 0;
+  let sampleSize = stream.type === "video" || declared < 0 ? 0 : declared;
+  let blockAlign = 0;
+  if (stream.type === "audio") {
+    blockAlign = stream.blockAlign > 0 ? stream.blockAlign : 0;
+    if (sampleSize && blockAlign && sampleSize !== blockAlign) sampleSize = blockAlign;
+    if (["aac", "flac", "mp2"].includes(stream.codecId) && blockAlign <= 4) blockAlign = 0;
+    if ((stream.codecId === "aac" && (blockAlign === 1024 || blockAlign === 4096) && sampleSize === blockAlign) ||
+      (stream.codecId === "mp3" && blockAlign === 1152 && sampleSize === 1152)) sampleSize = 0;
+  }
+  return {
+    sampleSize,
+    units: startUnits * Math.max(1, declared),
+    advance(length) { this.units += sampleSize ? length : blockAlign ? Math.ceil(length / blockAlign) : 1; },
+    seconds() { return stream.timeBase * (sampleSize ? Math.floor(this.units / sampleSize) : this.units); }
+  };
 }
 
 async function readIdx1({ read, fileSize, movi, idx1, streams, allocation }) {
@@ -139,7 +170,7 @@ async function readIdx1({ read, fileSize, movi, idx1, streams, allocation }) {
   const held = reserve(allocation, counts.reduce((sum, count) => sum + count, 0));
   try {
     const packets = counts.map(count => new StreamPackets(count));
-    const clocks = streams.map(stream => stream.startTimeSeconds ?? 0);
+    const clocks = streams.map(clockOf);
     for await (const { bytes } of blocks(read, idx1.start, idx1.end, IDX1_ENTRY_BYTES)) {
       for (let offset = 0; offset < bytes.length; offset += IDX1_ENTRY_BYTES) {
         const chunkId = bytes.toString("ascii", offset, offset + 4);
@@ -151,8 +182,8 @@ async function readIdx1({ read, fileSize, movi, idx1, streams, allocation }) {
         // FFmpeg takes the index flag alone, and every entry as a keyframe
         // when no entry carries it (avi_read_idx1).
         const keyframe = !anyKeyframe || !!(bytes.readUInt32LE(offset + 4) & AVIIF_KEYFRAME);
-        packets[id].push(start, length, clocks[id], keyframe);
-        clocks[id] += durationOf(streams[id], length);
+        packets[id].push(start, length, clocks[id].seconds(), keyframe);
+        clocks[id].advance(length);
       }
     }
     return new AviIndex({ packets, indexRanges: [[idx1.start - 8, fileSize - 1]], held, allocation });
@@ -202,9 +233,8 @@ async function readOpenDml({ read, fileSize, streams, allocation }) {
   const held = reserve(allocation, counts.reduce((sum, count) => sum + count, 0));
   try {
     const packets = counts.map(count => new StreamPackets(count));
-    const clocks = streams.map(stream => stream.startTimeSeconds ?? 0);
+    const clocks = streams.map(clockOf);
     for (const standard of parsed) {
-      const stream = streams[standard.id];
       const tableStart = standard.start + 32;
       const tableEnd = tableStart + standard.count * standard.entryBytes;
       for await (const { bytes } of blocks(read, tableStart, tableEnd, standard.entryBytes)) {
@@ -212,8 +242,8 @@ async function readOpenDml({ read, fileSize, streams, allocation }) {
           const start = standard.base + bytes.readUInt32LE(offset);
           const encoded = bytes.readUInt32LE(offset + 4), length = encoded & 0x7fffffff;
           if (length && (start < 8 || start + length > fileSize)) throw new Error("AVI OpenDML packet exceeds the file.");
-          packets[standard.id].push(start, length, clocks[standard.id], !(encoded & 0x80000000));
-          clocks[standard.id] += durationOf(stream, length);
+          packets[standard.id].push(start, length, clocks[standard.id].seconds(), !(encoded & 0x80000000));
+          clocks[standard.id].advance(length);
         }
       }
     }