@torrent-tv/proxy 2.95.33 → 2.95.35

package/package.json

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

package/services/viewer/playback-readiness.js

@@ -37,6 +37,10 @@ import {
   ZERO
 } from "./media-time.js";
 
+// Match the media element's allowance for a range that starts a few frames
+// after its current position (see server/public/domain/buffer-metrics.js).
+const CLIENT_RANGE_START_TOLERANCE_SECONDS = 0.25;
+
 /**
  * The mean rate predicted over a horizon by the integral of the measured rate.
  * Polling does not change the last measured service rate.
@@ -148,7 +152,7 @@ export function predictPlaybackReadiness(input = {}) {
   const position = toSeconds(at);
   const remaining = Math.max(0, duration - position);
   const measuredRanges = reported.map((ranges, trackIndex) => ranges ?
-    heldRanges(ranges, segmentsOf[trackIndex], unit) : null);
+    heldRanges(ranges, segmentsOf[trackIndex], unit, at) : null);
   const measured = measuredRanges.length > 0 && measuredRanges.every(Boolean);
   const heldEnd = measured ? earliest(...measuredRanges.map((ranges) => contiguousEnd(ranges, at))) : null;
   // The figure reported back is what the page said it holds; the widening by
@@ -511,13 +515,18 @@ function joinedPiece(served) {
  * @param {bigint} unit
  * @returns {import("./media-time.js").MediaRange[]}
  */
-function heldRanges(ranges, segments, unit) {
+function heldRanges(ranges, segments, unit, position) {
   const pieces = segments.flatMap((segment) => segment.ranges ?? []);
   const zero = mediaTime(0n, unit);
   const error = rescale(REPORTED_TIME_ERROR, unit);
+  const startTolerance = add(position, rescale(fromSeconds(CLIENT_RANGE_START_TOLERANCE_SECONDS), unit));
   const held = [];
   for (const range of ranges) {
-    const start = latest(zero, subtract(rescale(range.start, unit), error));
+    const reportedStart = rescale(range.start, unit);
+    let start = latest(zero, subtract(reportedStart, error));
+    if (compare(reportedStart, position) > 0 && compare(reportedStart, startTolerance) <= 0) {
+      start = position;
+    }
     const end = add(rescale(range.end, unit), error);
     const inside = pieces.filter((piece) => contains([{ start, end }], piece.start, piece.end));
     addMediaRange(held, { start, end, frame: latest(zero, ...inside.map(({ frame }) => frame)) });