@torrent-tv/proxy 2.95.22 → 2.95.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.95.22",
+  "version": "2.95.23",
   "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/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);
         }
       }
     }