@torrent-tv/proxy 2.95.34 → 2.95.36

package/package.json

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

package/routes/encode-input/get.js

@@ -21,10 +21,14 @@ export function handleEncodeInputGet(req, reply, { inputOf, refused = () => {} }
   if (!range || range.start >= length) return reply.code(416).header("Content-Range", `bytes */${length}`).send();
   // The answer runs to the end of the admitted range the read starts in, which
   // is what keeps FFmpeg inside the bytes the run holds. A shorter answer is
-  // not continued by every FFmpeg: 6.1 (ffmpeg-static) takes it for the end of
-  // the input and stops, where 8.1 sends a new request (http.c, EAGAIN at the
-  // 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).
+  // not continued by every FFmpeg: measured, 8.1.2 and 9.0.2 send a new
+  // request, while 5.1, 6.1, 7.0.2 (ffmpeg-static on Linux), 7.1 and 8.0 take
+  // it for a read error. A cap of 1 MiB here ended every original-source
+  // segment longer than that on 6.1 (torrent-tv/meta#151). The end of an
+  // admitted range is therefore only reached where FFmpeg needs nothing more,
+  // and a byte past it is refused, which from 7.1 on ends the run: every read
+  // FFmpeg makes, its stream search at open included, must be named by the
+  // container (torrent-tv/meta#165).
   const held = input.read(fileIndex, range.start, range.end, true);
   if (!held) {
     // FFmpeg asked for a byte the run was not given: the container named too

package/services/encode/EncodeRuns.js

@@ -494,11 +494,13 @@ export class EncodeRuns {
     // each: 454 pieces against 401 on the field file.
     for (const [address, sessions] of byOutput) {
       const timeline = sessions[0].timeline;
+      const spec = sessions[0].spec;
       this.#host.encodeOrchestrator.notePriorityMap(
         address,
         timeline?.inSegments?.(
           this.#host.priority.mapForOutput(address),
-          Number(timeline?.segmentCount) || 0
+          Number(timeline?.segmentCount) || 0,
+          { runsPastEnd: Boolean(spec?.audio) && spec?.transcodesAudio !== true }
         ) ?? []
       );
     }

package/services/encode/output/Timeline.js

@@ -159,10 +159,13 @@ export class Timeline {
    * @param {import("../../viewer/PriorityMap.js").PriorityMap} map - One number
    *   per second of film.
    * @param {number} segmentCount - How many pieces this output has.
+   * @param {{ runsPastEnd?: boolean }} [shape] - `runsPastEnd`: the output's
+   *   pieces copy a stream, which is cut where its packets end, so a piece
+   *   holds sound past its published end by up to one packet.
    * @returns {import("../../viewer/PriorityMap.js").DemandZone[]} Runs of pieces
    *   that agree. Empty where nothing is stated, which says nobody is coming.
    */
-  inSegments(map, segmentCount) {
+  inSegments(map, segmentCount, { runsPastEnd = false } = {}) {
     if (!(segmentCount > 0) || !map || !(map.durationSeconds > 0)) {
       return [];
     }
@@ -173,9 +176,17 @@ export class Timeline {
       // whole, so it is wanted as soon as the soonest second inside it is
       // wanted — and the piece a viewer is standing in the middle of is wanted
       // exactly as much as the second under their feet.
+      // A COPIED PIECE ALSO HOLDS THE SECOND ITS END FALLS IN. A copy ends at
+      // the first packet boundary at or after its published end, and the
+      // player places the next piece where this one truly ends (hls.js
+      // `updateFragPTSDTS` carries a parsed piece's end to every later one).
+      // Field 2026-10-09, MP3 copied out of an AVI on a 4 s grid: pieces ended
+      // up to 24 ms late, and a seek to 4000 s asked for the piece ending at
+      // 4000 s, which nothing made because second 4000 belonged to the next.
       const from = Math.max(0, Math.floor(this.publishedStartOf(index)));
+      const end = this.publishedStartOf(index + 1);
       const until = index + 1 < segmentCount
-        ? Math.max(from + 1, Math.ceil(this.publishedStartOf(index + 1)))
+        ? Math.max(from + 1, runsPastEnd ? Math.floor(end) + 1 : Math.ceil(end))
         : map.durationSeconds;
       let priority = 0;
       let withinSeconds = Number.POSITIVE_INFINITY;

package/services/encode/source-command.js

@@ -17,6 +17,8 @@ export function buildRunCommand({
   audioFile,
   inputUrl,
   audioInputUrl: audioInputUrlGiven,
+  inputOpenArgs = [],
+  audioInputOpenArgs = [],
   timeline,
   output,
   segmentFormat,
@@ -126,7 +128,7 @@ export function buildRunCommand({
     if (audioSeek > audioFileStartTime) {
       args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(audioSeek));
     }
-    args.push("-i", audioInputUrl);
+    args.push(...audioInputOpenArgs, "-i", audioInputUrl);
   };
 
   // Whether an output `-ss` already cuts at the interval's start.
@@ -136,7 +138,7 @@ export function buildRunCommand({
     if (snappedKeyframe > sourceStartTime) {
       args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, keyframes, reorderDepth }, snappedKeyframe)));
     }
-    args.push("-i", inputUrl);
+    args.push(...inputOpenArgs, "-i", inputUrl);
     pushAudioInput(snappedKeyframe);
     if (residualSeconds > 0 && !keyframeGrid) {
       args.push("-ss", ffmpegSeconds(residualSeconds));
@@ -146,7 +148,7 @@ export function buildRunCommand({
     if (seekAt > sourceStartTime) {
       args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(seekAt));
     }
-    args.push("-i", inputUrl);
+    args.push(...inputOpenArgs, "-i", inputUrl);
     pushAudioInput(seekAt);
   }
   // An input seek lands on the picture's keyframe at or before the time asked
@@ -269,6 +271,10 @@ export function buildOriginalCommand(params) {
   const audio = sourceFor("audio") ?? primary;
   if (!primary) throw new Error("The selected source track is absent from original input.");
   const url = source => new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href;
+  // The container named the bytes FFmpeg's stream search reads for this much
+  // media time; the search is told the same, whatever its own default.
+  const openArgs = source => Number.isFinite(source.input.streamSearchSeconds)
+    ? ["-analyzeduration", String(Math.round(source.input.streamSearchSeconds * 1_000_000))] : [];
   const local = [...stretch, to + (to - last)];
   const localTimeline = { ...timeline, published: local,
     boundaries: local, sourceStartOf: () => primary.input.from ?? from + primary.timeShiftSeconds };
@@ -277,6 +283,7 @@ export function buildOriginalCommand(params) {
     reorderDepth: primary.input.selections.find(selection => selection.track.type === "video")?.track.reorderDepth ?? 0,
     inputFile: { startTime: primary.timeShiftSeconds }, audioFile: { startTime: audio.timeShiftSeconds },
     inputUrl: url(primary), audioInputUrl: audio !== primary && !audioOnly ? url(audio) : "",
+    inputOpenArgs: openArgs(primary), audioInputOpenArgs: openArgs(audio),
     audioSourceTrackIndex: audio.input.selections.find(selection => selection.track.type === "audio")?.index ?? 0 });
   const args = command.args;
   // The segment muxer otherwise shifts negative initial DTS to zero before

package/services/media/container/AviContainer.js

@@ -7,6 +7,7 @@
  * reassembled only for an AVI that states no index.
  */
 
+import { FFMPEG_STREAM_SEARCH_SECONDS } from "./ffmpeg-stream-search.js";
 import { Container } from "./Container.js";
 import { VideoTrack } from "../tracks/VideoTrack.js";
 import { AudioTrack } from "../tracks/AudioTrack.js";
@@ -162,7 +163,8 @@ export class AviContainer extends Container {
    * The bytes FFmpeg reads to produce `[from, to)` from the original file:
    * the declarations and the start of `movi` it probes, the index it loads at
    * open (`idx1` to the end of the file, or every OpenDML standard index), the
-   * first packet of each stream it inspects, and the selected streams' packets
+   * first packet of each stream it inspects, the stretch its stream search
+   * reads from the start of `movi`, and the selected streams' packets
    * around the interval. Each range is held one input buffer of FFmpeg past its
    * last named byte, because that buffer is filled ahead of the packet parsed.
    */
@@ -182,7 +184,11 @@ export class AviContainer extends Container {
     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(),
+    // FFmpeg's stream search reads `movi` on from its start for its stated
+    // media time: every stream's packets in file order, from the first.
+    const search = index.mediaRanges({ from: 0, to: FFMPEG_STREAM_SEARCH_SECONDS, picture: null,
+      streams: requested.map(track => track.trackNumber) });
+    const ranges = [[0, movi.start + 3], ...index.indexRanges, ...index.firstPackets(), ...search,
       ...index.mediaRanges({ from: interval.from, to: interval.to, picture: picture?.trackNumber ?? null,
         streams: requested.map(track => track.trackNumber) })].map(padded);
     ranges.sort((left, right) => left[0] - right[0]);
@@ -192,7 +198,8 @@ export class AviContainer extends Container {
       if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
       else union.push([...range]);
     }
-    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize };
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize,
+      streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 
   packetIndexBytes() { return (this.#packets ?? this.#scan?.index)?.allocatedBytes() ?? 0; }

package/services/media/container/MatroskaContainer.js

@@ -32,6 +32,7 @@
  * only way in.
  */
 
+import { FFMPEG_STREAM_SEARCH_SECONDS } from "./ffmpeg-stream-search.js";
 import { Container } from "./Container.js";
 import { VideoTrack } from "../tracks/VideoTrack.js";
 import { h264Configuration } from "./h264-configuration.js";
@@ -572,7 +573,8 @@ export class MatroskaContainer extends Container {
   }
 
   /** Original-file ranges from Cues alone, without reading media block headers.
-   * FFmpeg needs the declarations and seek table as well as complete clusters.
+   * FFmpeg needs the declarations, the Clusters its stream search reads from the
+   * first one, and the seek table as well as complete clusters.
    * One preceding cluster retains preroll; one following cluster covers demux
    * lookahead beyond the presentation cut. No packet payload is parsed here.
    */
@@ -627,7 +629,11 @@ export class MatroskaContainer extends Container {
     if (cuesEnd === null) return { kind: "terminal", reason: "source-seek-index-is-unbounded" };
     const requestBytes = 1024 * 1024;
     const paddedEnd = end => Math.min(this.fileSize - 1, end + requestBytes);
-    const ranges = [[0, paddedEnd(layout.firstClusterAt - 1)],
+    // FFmpeg's stream search reads on from the first Cluster for its stated
+    // media time and stops on the first packet past it, which lies before the
+    // first Cue later than that time; the padding holds its read-ahead.
+    const searchEnd = points[firstAt(points[0].seconds + FFMPEG_STREAM_SEARCH_SECONDS, true)];
+    const ranges = [[0, paddedEnd((searchEnd ? searchEnd.at : layout.segmentEnd) - 1)],
       [points[first].at, paddedEnd(mediaEnd)], [layout.cuesAt, paddedEnd(cuesEnd - 1)],
       [Math.max(0, this.fileSize - requestBytes), this.fileSize - 1]];
     // SeekHead may name top-level declarations after media clusters. Preserve
@@ -645,7 +651,8 @@ export class MatroskaContainer extends Container {
       if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
       else union.push([...range]);
     }
-    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize };
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize,
+      streamSearchSeconds: FFMPEG_STREAM_SEARCH_SECONDS };
   }
 
   async readPacketIndex(interval) {

package/services/media/container/ffmpeg-stream-search.js

@@ -0,0 +1,15 @@
+/**
+ * How far into a file FFmpeg reads, at open, to learn its streams
+ * (`avformat_find_stream_info`): until a stream has given it this much media
+ * time (`-analyzeduration`), unless every stream is known sooner.
+ *
+ * A container that names the bytes of an original-source run names this
+ * stretch from the first media too, and the run gives FFmpeg the same figure,
+ * so the read and the bytes held agree whatever FFmpeg's own default is. A
+ * read past the bytes held is refused, and from 7.1 on FFmpeg does not recover
+ * from that refusal: the run ends with nothing made (torrent-tv/meta#165).
+ *
+ * Five seconds is FFmpeg's own default for these containers
+ * (`5*AV_TIME_BASE` in avformat_find_stream_info), stated rather than chosen.
+ */
+export const FFMPEG_STREAM_SEARCH_SECONDS = 5;