@torrent-tv/proxy 2.95.4 → 2.95.6

package/package.json

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

package/server.js

@@ -467,9 +467,7 @@ export async function startProxyServer({
         const navigation = await containerOrchestrator.inspect(intervalParams, "source-navigation");
         if (navigation.kind !== "result") continue;
         const originalRanges = navigation.value;
-        const packets = originalRanges && !zone.urgent
-          ? { kind: "result", value: await container.readMappedSourceRanges(interval) }
-          : await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
+        const packets = await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
         if (!map.isCurrent()) return [];
         if (packets.kind !== "result") continue;
         const input = originalRanges ? packets.value : new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });

package/services/encode/source-command.js

@@ -64,6 +64,13 @@ export function buildRunCommand({
   const audioCodecArgs = transcodeAudio
     ? ["-c:a", "aac", "-ac", "2", "-b:a", `${AUDIO_TRANSCODE_KBPS}k`]
     : ["-c:a", "copy"];
+  // Under `-copyts` FFmpeg trims a decoded stream at `-ss` PLUS its own idea of
+  // the file's start, ignoring `-seek_timestamp` (ffmpeg_demux.c, n8.1.2,
+  // `trim_start_us`): an absolute seek would be trimmed a second start later.
+  // On the keyframe grid its trim is therefore switched off on every input and
+  // the decoded soundtrack is cut here, on the picture file's clock, which is
+  // the clock every stream carries there.
+  const inputSeekArgs = keyframeGrid ? ["-noaccurate_seek"] : ["-accurate_seek"];
 
   const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
   if (transcodeVideo && Array.isArray(videoEncoder.inputArgs)) {
@@ -71,16 +78,23 @@ export function buildRunCommand({
   }
   const inputStartSeconds = inputIndex === safeIndex ? startSeconds :
     publishedStartTime(timeline, inputIndex, segmentDurationSec);
-  const seekSeconds = timeline.cutGrid === "keyframe"
-    ? inputStartSeconds + sourceStartTime
-    : inputStartSeconds;
+  // ONE CLOCK FOR EVERY INPUT SEEK. Each `-ss` below is an absolute timestamp
+  // of the file it seeks, given with `-seek_timestamp 1`: without it FFmpeg
+  // adds its own idea of the file's start time to the value, which is a second
+  // copy of a start this code already knows. Published positions begin at
+  // zero, so the picture's instant is the published time plus the picture
+  // file's start; keyframe times are on the same file clock; a soundtrack in
+  // another file is the same instant on that file's clock. Whether the cuts
+  // follow the source's keyframes or an even grid changes how the run ENDS
+  // and what its output timestamps are, never where its input is.
+  const seekAt = inputStartSeconds + sourceStartTime;
   const carriedKeyframe = timeline.cutGrid === "keyframe" && typeof timeline.sourceStartOf === "function"
     ? timeline.sourceStartOf(inputIndex)
     : null;
   const snappedKeyframe = Number.isFinite(carriedKeyframe)
     ? carriedKeyframe
     : (Array.isArray(keyframes?.times) && keyframes.times.length > 0
-      ? nearestKeyframeAtOrBefore(keyframes.times, seekSeconds)
+      ? nearestKeyframeAtOrBefore(keyframes.times, seekAt)
       : null);
   const audioInputUrl =
     typeof audioInputUrlGiven === "string" && audioInputUrlGiven.length > 0
@@ -98,8 +112,8 @@ export function buildRunCommand({
    * order wrong would silently turn the audio file's seek into a trim of the
    * finished stream.
    *
-   * @param {number} inputSeekSeconds - Where to start, on the PICTURE's
-   *   timeline. Translated to the soundtrack file's own here.
+   * @param {number} inputSeekSeconds - Where to start, on the PICTURE
+   *   file's clock. Translated to the soundtrack file's own here.
    */
   const pushAudioInput = (inputSeekSeconds) => {
     if (!audioInputUrl) {
@@ -108,17 +122,17 @@ export function buildRunCommand({
     if (audioTimelineShift !== 0 && keyframeGrid) {
       args.push("-itsoffset", ffmpegSeconds(-audioTimelineShift));
     }
-    const audioSeek = Math.max(0, inputSeekSeconds + audioTimelineShift);
-    if (audioSeek > 0) {
-      args.push("-accurate_seek", "-ss", ffmpegSeconds(audioSeek));
+    const audioSeek = inputSeekSeconds + audioTimelineShift;
+    if (audioSeek > audioFileStartTime) {
+      args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(audioSeek));
     }
     args.push("-i", audioInputUrl);
   };
 
   if (snappedKeyframe !== null) {
-    const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
-    if (snappedKeyframe > 0) {
-      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, keyframes, reorderDepth }, snappedKeyframe)));
+    const residualSeconds = Math.max(0, seekAt - snappedKeyframe);
+    if (snappedKeyframe > sourceStartTime) {
+      args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, keyframes, reorderDepth }, snappedKeyframe)));
     }
     args.push("-i", inputUrl);
     pushAudioInput(snappedKeyframe);
@@ -126,11 +140,11 @@ export function buildRunCommand({
       args.push("-ss", ffmpegSeconds(residualSeconds));
     }
   } else {
-    if (seekSeconds > 0) {
-      args.push("-accurate_seek", "-ss", ffmpegSeconds(seekSeconds));
+    if (seekAt > sourceStartTime) {
+      args.push("-seek_timestamp", "1", ...inputSeekArgs, "-ss", ffmpegSeconds(seekAt));
     }
     args.push("-i", inputUrl);
-    pushAudioInput(seekSeconds);
+    pushAudioInput(seekAt);
   }
   if (!keyframeGrid) {
     if (startSeconds > 0) {
@@ -146,12 +160,20 @@ export function buildRunCommand({
   const publishedGrid = publishedGridFor(timeline);
   if (runEnd >= safeIndex && Array.isArray(publishedGrid) && publishedGrid[runEnd + 1] > 0) {
     const endsAt = publishedGrid[runEnd + 1];
-    if (transcodeVideo) {
-      args.push("-t", ffmpegSeconds(Math.max(0.1, endsAt - publishedGrid[safeIndex])));
+    if (keyframeGrid) {
+      // `-copyts` keeps the input's own clock up to the muxer, and an output
+      // `-to` is compared there, before `-output_ts_offset` moves it.
+      args.push("-to", ffmpegSeconds(endsAt + sourceStartTime));
     } else {
-      args.push("-to", ffmpegSeconds(endsAt));
+      // The output clock starts at zero where this run begins, so the end is
+      // a length; an output `-to` would be read as a length from zero too and
+      // run past the interval by its own start.
+      args.push("-t", ffmpegSeconds(Math.max(0.1, endsAt - startSeconds)));
     }
   }
+  if (keyframeGrid && transcodeAudio && !servesAudioSeparately) {
+    audioCodecArgs.push("-af", `atrim=start=${ffmpegSeconds(seekAt)}`);
+  }
   if (audioOnly === true) {
     args.push("-vn", "-map", `0:a:${audioSourceTrackIndex}?`, ...audioCodecArgs);
   } else if (servesAudioSeparately) {
@@ -217,7 +239,7 @@ export function buildOriginalCommand(params) {
   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;
   const localTimeline = { ...timeline, published: [from, to, to + (to - from)],
-    boundaries: [from, to, to + (to - from)], sourceStartOf: () => timeline.sourceStartOf?.(startIndex) ?? from + primary.timeShiftSeconds };
+    boundaries: [from, to, to + (to - from)], sourceStartOf: () => primary.input.from ?? from + primary.timeShiftSeconds };
   const command = buildRunCommand({ ...params, startIndex: 0, endIndex: 0, timeline: localTimeline,
     videoSourceTrackIndex: primary.input.selections.find(selection => selection.track.type === "video")?.index ?? 0,
     reorderDepth: primary.input.selections.find(selection => selection.track.type === "video")?.track.reorderDepth ?? 0,
@@ -229,7 +251,7 @@ export function buildOriginalCommand(params) {
   // the inner muxer writes its edit list, moving B-picture PTS off the source.
   args.splice(args.indexOf("-f"), 0, "-avoid_negative_ts", "disabled");
   const formatOptions = args.indexOf("-segment_format_options");
-  if (formatOptions >= 0) args[formatOptions + 1] += ":avoid_negative_ts=disabled";
+  if (formatOptions >= 0) args[formatOptions + 1] += ":avoid_negative_ts=disabled:movie_timescale=1000000";
   const numbering = args.indexOf("-segment_start_number");
   if (numbering < 0) throw new Error("The format cannot produce finite original-source segments.");
   args[numbering + 1] = String(startIndex);

package/services/media/container/MatroskaContainer.js

@@ -600,7 +600,7 @@ export class MatroskaContainer extends Container {
       .filter(position => !video || position.track === video.trackNumber)
       .map(position => ({ at: position.clusterAt, seconds: point.ticks * layout.secondsPerTick })))
       .sort((left, right) => left.seconds - right.seconds || left.at - right.at);
-    if (!points.length) return super.readSourceRanges(interval);
+    if (!points.length) return { kind: "needs-index", reason: "source-has-no-cue-map" };
     const preroll = Math.max(0, ...requested.map(track => track.seekPrerollSeconds ?? 0));
     const firstAt = (seconds, strict) => {
       let low = 0, high = points.length;
@@ -632,7 +632,7 @@ export class MatroskaContainer extends Container {
       [Math.max(0, this.fileSize - requestBytes), this.fileSize - 1]];
     // SeekHead may name top-level declarations after media clusters. Preserve
     // their original bytes instead of reconstructing declarations for FFmpeg.
-    for (const at of [layout.infoAt, layout.tracksAt]) {
+    for (const at of [layout.infoAt, layout.tracksAt, layout.tagsAt, layout.chaptersAt, layout.attachmentsAt]) {
       if (at === null || at < layout.firstClusterAt) continue;
       const end = await elementEnd(at);
       if (end === null) return { kind: "terminal", reason: "source-declarations-are-unbounded" };

package/services/torrent/download/SwarmSelection.js

@@ -17,14 +17,28 @@
  * vendored 2.8.5: selections are sorted by priority only when one is inserted,
  * and `shufflePriority` then moves the selection just served to the back of the
  * whole non-zero group. Distinct numbers therefore order the list once and
- * round-robin it afterwards. So the ordering is kept HERE, by choosing what to
- * state at all, and the library is given only the distinction it honours:
- * non-zero for what is wanted now, zero for the speculative tail.
+ * round-robin it afterwards. The library honours one distinction: non-zero
+ * before zero. A wire with nothing left to take from the non-zero selections
+ * goes on to the zero ones, and within a selection it takes the earliest piece
+ * it holds.
+ *
+ * **So everything wanted is stated, and only the first class is non-zero.**
+ * The first class is the most urgent level that is still missing anything, at
+ * its highest priority, whatever its deadlines. Everything else that is not
+ * speculative is stated at zero, so it is fetched only by a wire that would
+ * otherwise stand idle. Stating only the earliest deadline, as this did after
+ * #95, left every peer that held none of that segment's pieces without a
+ * request: on Home Assistant, with three peers each holding every third piece
+ * and one complete slow peer, twelve segments took 184 s at 0.61 MiB/s against
+ * 18.3 s at 6.1 MiB/s when the whole band was stated
+ * (`research/download-translation-2026-10-07.md`, torrent-tv/meta#95).
+ * Speculative levels stay withheld while anything urgent is missing anywhere,
+ * because the link is shared.
  */
 
 import {
+  isConditional,
   piecesOf,
-  selectionPriority,
   Urgency,
   urgencyName
 } from "../demand/index.js";
@@ -68,39 +82,40 @@ export class SwarmSelection {
    *   torrent is still waiting for something urgent. The registry works it out
    *   once and hands the same answer to every selection, because the link is
    *   shared and the question is not a per-torrent one.
+   * @param {{ urgency: number, priority: number } | null} [options.firstClass] -
+   *   The most urgent missing level and its highest priority across every
+   *   torrent. Without it, this torrent's own.
    * @returns {{ stated: number, withdrawn: number }}
    */
-  reconcile({ speculativeAllowed = true, maximumUrgency = Infinity, minimumPriority = 1, latestDeadlineAt = Infinity } = {}) {
-    const windows=this.#register.windows();
-    const missing=windows.filter(window=>!this.#isSatisfied(window));
-    const urgency=missing.length?Math.min(...missing.map(window=>window.urgency)):null;
-    const eligible=missing.filter(window=>window.urgency===urgency);
-    const priority=eligible.length?Math.max(...eligible.map(window=>window.priority)):null;
-    const ranked=eligible.filter(window=>window.priority===priority);
-    const deadlineAt=ranked.length?Math.min(...ranked.map(window=>window.deadlineAt)):Infinity;
-    const active=urgency===null||urgency>maximumUrgency||priority<minimumPriority||deadlineAt>latestDeadlineAt||(!speculativeAllowed&&urgency>=Urgency.TAIL)?[]:
-      ranked.filter(window=>window.deadlineAt===deadlineAt);
+  reconcile({ speculativeAllowed = !this.hasUrgentMissing(), firstClass = null } = {}) {
+    const missing = this.#register.windows().filter(window => !this.#isSatisfied(window));
+    const first = firstClass ?? this.missingBand();
     /** @type {Map<string, { from: number, to: number, priority: number }>} */
     const wanted = new Map();
-    for (const window of active) {
+    for (const priority of [1, 0]) {
+      const ranges = [];
+      for (const window of missing) {
+        if (!speculativeAllowed && isConditional(window.urgency)) continue;
+        // Speculative levels are never the first class: the library keeps
+        // zero-priority selections last and never rotates them above.
+        const inFirstClass = first !== null && !isConditional(window.urgency)
+          && window.urgency === first.urgency && window.priority >= first.priority;
+        if ((inFirstClass ? 1 : 0) !== priority) continue;
         const range = this.#piecesFor(window);
-        if (!range) {
-          continue;
-        }
-        // Merged by range and priority, not by claimant: two readers wanting
-        // the same pieces are one instruction to the swarm.
-        const key = `${range.from}-${range.to}-${selectionPriority(window.urgency)}`;
-        wanted.set(key, { from: range.from, to: range.to, priority: selectionPriority(window.urgency) });
+        if (range) ranges.push(range);
+      }
+      // Merged within one priority: two readers wanting the same or adjacent
+      // pieces are one instruction, and an unchanged map restates nothing.
+      ranges.sort((a, b) => a.from - b.from);
+      const union = [];
+      for (const range of ranges) {
+        const previous = union.at(-1);
+        if (previous && range.from <= previous.to + 1) previous.to = Math.max(previous.to, range.to);
+        else union.push({ from: range.from, to: range.to, priority });
+      }
+      for (const range of union) wanted.set(`${range.from}-${range.to}-${priority}`, range);
     }
 
-    // Public selections merge adjacent ranges. Publish their union so an
-    // unchanged map does not repeatedly replace the library's merged range.
-    const ordered=[...wanted.values()].sort((a,b)=>a.from-b.from);
-    wanted.clear();
-    const union=[];
-    for(const range of ordered){const previous=union.at(-1);if(previous&&range.from<=previous.to+1)previous.to=Math.max(previous.to,range.to);else union.push({...range});}
-    for(const range of union)wanted.set(`${range.from}-${range.to}-${range.priority}`,range);
-
     let withdrawn = 0;
     for (const [key, range] of [...this.#stated]) {
       if (wanted.has(key)) {

package/services/torrent/download/registry.js

@@ -116,16 +116,18 @@ export function reconcileAll() {
   if (publishingSelections) return { torrents: live.size, speculativeAllowed: false, stated: 0, withdrawn: 0 };
   const entries = [...live];
   const speculativeAllowed = !entries.some((entry) => entry.selection.hasUrgentMissing());
-  const bands=entries.map(entry=>entry.selection.missingBand()).filter(Boolean);
-  const maximumUrgency=bands.length?Math.min(...bands.map(band=>band.urgency)):Infinity;
-  const minimumPriority=bands.length?Math.max(...bands.filter(band=>band.urgency===maximumUrgency).map(band=>band.priority)):1;
-  const latestDeadlineAt=bands.length?Math.min(...bands.filter(band=>band.urgency===maximumUrgency&&band.priority===minimumPriority).map(band=>band.deadlineAt)):Infinity;
+  // The first class across every torrent: the most urgent missing level and
+  // its highest priority. Each selection states it non-zero and the rest zero.
+  const bands = entries.map(entry => entry.selection.missingBand()).filter(Boolean);
+  const urgency = bands.length ? Math.min(...bands.map(band => band.urgency)) : null;
+  const firstClass = urgency === null ? null
+    : { urgency, priority: Math.max(...bands.filter(band => band.urgency === urgency).map(band => band.priority)) };
   let stated = 0;
   let withdrawn = 0;
   publishingSelections = true;
   try {
     for (const entry of entries) {
-      const result = entry.selection.reconcile({ speculativeAllowed, maximumUrgency, minimumPriority, latestDeadlineAt });
+      const result = entry.selection.reconcile({ speculativeAllowed, firstClass });
       stated += result.stated;
       withdrawn += result.withdrawn;
     }