@torrent-tv/proxy 2.97.20 → 2.97.22

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -281,6 +281,21 @@ export class EncodeRuns {
     return this.#runsByInputToken.get(runToken)?.originalInput ?? null;
   }
 
+  /**
+   * What FFmpeg's caches may hold for the live runs that read an original
+   * file: at most what each was admitted, since a cache keeps what its run
+   * read of it (`source-command.js`).
+   *
+   * @returns {number}
+   */
+  inputCacheBytes() {
+    let bytes = 0;
+    for (const run of this.#runsByInputToken.values()) {
+      if (run.isAlive && run.originalInput) bytes += Math.max(0, Number(run.originalInput.bytes) || 0);
+    }
+    return bytes;
+  }
+
   /**
    * @param {object} output
    * @returns {number}

package/services/encode/source-command.js

@@ -270,7 +270,15 @@ export function buildOriginalCommand(params) {
   const primary = sourceFor(audioOnly ? "audio" : "video");
   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;
+  // READ THROUGH FFMPEG'S CACHE, so a return to bytes already read is not a
+  // new request. An OpenDML AVI's open seeks from its super index in the header
+  // to each standard index and back: on the field's two-hour AVI, 195 indexes
+  // made 390 requests and 636-1243 MB of answers, and the first piece came 4.8 s
+  // after the start against 2.8 s through the cache, which made 3 requests;
+  // the pieces were the same to the byte, on FFmpeg 6.1 and 8.1.2 (Home
+  // Assistant 2026-10-13, torrent-tv/meta#178). The cache's file holds what
+  // FFmpeg read and is counted by the budget (`EncodeRuns.inputCacheBytes`).
+  const url = source => `cache:${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)

package/services/media/container/AviContainer.js

@@ -304,9 +304,19 @@ export class AviContainer extends Container {
   }
 
   /**
-   * Duration from the main AVI header, per the RIFF AVI specification: the
-   * header states microseconds per frame and the total number of frames, and
-   * their product is the length.
+   * The length of the film, by the rule FFmpeg's AVI demuxer reads it with
+   * (libavformat/avidec.c n8.1, the `strh` case): a stream whose samples vary
+   * in size — every picture, and sound such as MP3 declared with
+   * `dwSampleSize` 0 — lasts `dwLength` units of its own `dwScale/dwRate`, and
+   * a stream of fixed-size samples is given no length by its header. The film
+   * lasts as long as the longest stream that has one.
+   *
+   * The main header's frame count is not that length. OpenDML has
+   * `avih.dwTotalFrames` count the first RIFF only, so a film with a second
+   * RIFF read as 8136.0 s of its 8998.1 and its last fourteen minutes were
+   * neither listed nor reachable (Home Assistant 2026-10-13,
+   * torrent-tv/meta#178). FFmpeg skips `dmlh` as well. The main header is
+   * read only when no stream states a length.
    *
    * An AVI has no edit list and no timeline offset of any kind, so its start is
    * zero — a declaration of the format itself, not an absence.
@@ -319,11 +329,17 @@ export class AviContainer extends Container {
     }
     /** @type {import("./Container.js").ContainerMediaInfo} */
     const info = { format: this.formatName, durationSeconds: null, startTimeSeconds: 0 };
-    const { avih } = await this.#readHeaders();
-    const microsecondsPerFrame = avih?.readUInt32LE(0) ?? 0;
-    const totalFrames = avih?.readUInt32LE(16) ?? 0;
-    if (microsecondsPerFrame > 0 && totalFrames > 0) {
-      info.durationSeconds = (microsecondsPerFrame * totalFrames) / 1e6;
+    const stated = (await this.readTracks())
+      .filter(track => ["video", "audio"].includes(track.type) && (track.type === "video" || track.sampleSize === 0))
+      .map(track => track.durationSeconds)
+      .filter(seconds => seconds > 0);
+    if (stated.length > 0) {
+      info.durationSeconds = Math.max(...stated);
+    } else {
+      const { avih } = await this.#readHeaders();
+      const microsecondsPerFrame = avih?.readUInt32LE(0) ?? 0;
+      const totalFrames = avih?.readUInt32LE(16) ?? 0;
+      if (microsecondsPerFrame > 0 && totalFrames > 0) info.durationSeconds = (microsecondsPerFrame * totalFrames) / 1e6;
     }
     this.mediaInfo = info;
     return info;

package/services/media/container/MatroskaContainer.js

@@ -363,10 +363,20 @@ export class MatroskaContainer extends Container {
    * Kept only once it has been read: a head that had not arrived used to leave
    * an empty answer here for the life of the container.
    *
+   * `Duration` is optional (RFC 9559 §5.1.2.4), and a file written as it was
+   * streamed states none. Such a film lasts to the end of its last frame, which
+   * the complete packet index knows: the plan asks for that index when no
+   * length is stated and then asks here again, and an answer kept from before
+   * the index ended the opening with `media-duration-unavailable`
+   * (torrent-tv/meta#178).
+   *
    * @returns {Promise<import("./Container.js").ContainerMediaInfo>}
    */
   async readMediaInfo() {
     if (this.mediaInfo) {
+      if (this.mediaInfo.durationSeconds === null && this.#packets) {
+        this.mediaInfo = { ...this.mediaInfo, durationSeconds: await this.#lastFrameEnd(this.mediaInfo.startTimeSeconds) };
+      }
       return this.mediaInfo;
     }
     /** @type {import("./Container.js").ContainerMediaInfo} */
@@ -394,10 +404,36 @@ export class MatroskaContainer extends Container {
     if (layout.firstClusterAt !== null) {
       info.startTimeSeconds = await clusterTimestampSeconds(reader, layout.firstClusterAt, layout);
     }
+    // `Duration` runs from the Segment's timestamp zero, and a muxer that keeps
+    // its source's timestamps (FFmpeg's does) puts the first Cluster later. The
+    // plan's timeline begins at that Cluster, as every other container states
+    // its length, so what lies before it is not the film's: counted in, a file
+    // starting at 5 s listed five seconds past its last frame
+    // (torrent-tv/meta#178).
+    if (info.durationSeconds !== null && info.startTimeSeconds > 0) {
+      const shown = info.durationSeconds - info.startTimeSeconds;
+      info.durationSeconds = shown > 0 ? shown : null;
+    }
+    if (info.durationSeconds === null && this.#packets) info.durationSeconds = await this.#lastFrameEnd(info.startTimeSeconds);
     this.mediaInfo = info;
     return info;
   }
 
+  /**
+   * How long after the start of the timeline the last picture or sound frame
+   * of the complete packet index ends; null when none does.
+   *
+   * @param {number | null} startSeconds
+   */
+  async #lastFrameEnd(startSeconds) {
+    const ends = (await this.readTracks())
+      .filter(track => ["video", "audio"].includes(track.type))
+      .map(track => this.#packets.boundsOf(track.trackNumber)?.end)
+      .filter(Number.isFinite);
+    const length = ends.length > 0 ? Math.max(...ends) - (startSeconds ?? 0) : 0;
+    return length > 0 ? length : null;
+  }
+
   /**
    * What the file states about the work: `Info/Title`, the `Tags` that apply
    * to the whole file, the titles of its chapters and tracks, and whether it
@@ -712,7 +748,9 @@ export class MatroskaContainer extends Container {
     }
     const index = await readMatroskaPackets({ readRange: this.readRange,
       fileSize: this.fileSize, portionBytes: this.portionBytes, layout, tracks,
-      durationSeconds: info.durationSeconds, interval, state, packetMemory: this.packetMemory });
+      // The last frame ends where the film does, on the packets' own clock.
+      endSeconds: info.durationSeconds === null ? null : info.durationSeconds + (info.startTimeSeconds ?? 0),
+      interval, state, packetMemory: this.packetMemory });
     if (index.isComplete() && state.startAt === layout.firstClusterAt) {
       this.#packets = index;
     }

package/services/media/container/Mp4Container.js

@@ -620,6 +620,16 @@ export class Mp4Container extends Container {
     info.startTimeSeconds = movieTimescale > 0
       ? Mp4Container.#emptyEditSeconds(moov, header, movieTimescale)
       : null;
+    // `mvhd` states the length of the longest track, and a track lasts as long
+    // as its edits, the empty one included (ISO/IEC 14496-12, 8.2.2 and 8.6.6).
+    // The film is shown from the end of that empty edit, and the plan's
+    // timeline begins there — as every other container states its length —
+    // so the edit is not the film's. Counted in, a file starting at 5 s listed
+    // five seconds past its last frame (torrent-tv/meta#178).
+    if (info.durationSeconds !== null && info.startTimeSeconds > 0) {
+      const shown = info.durationSeconds - info.startTimeSeconds;
+      info.durationSeconds = shown > 0 ? shown : null;
+    }
     return info;
   }
 

package/services/media/container/matroska-packets.js

@@ -10,7 +10,7 @@ const CLUSTER = 0x1f43b675;
 const LEVEL_ONE = new Set([CLUSTER, 0x1c53bb6b, 0x114d9b74, 0x1549a966, 0x1654ae6b, 0x1043a770, 0x1941a469, 0x1254c367]);
 
 /** Index frame addresses by reading structural headers, never frame bodies. */
-export async function readMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, durationSeconds, interval, packetMemory, state = {} }) {
+export async function readMatroskaPackets({ readRange, fileSize, portionBytes, layout, tracks, endSeconds, interval, packetMemory, state = {} }) {
   const reader = new ElementReader({ read: readRange, fileSize, portionBytes });
   const declared = new Map(tracks.filter(track => ["video", "audio", "subtitle"].includes(track.type)).map(track => [track.trackNumber, track]));
   if (!state.packets) {
@@ -18,7 +18,7 @@ export async function readMatroskaPackets({ readRange, fileSize, portionBytes, l
     state.at ??= layout.firstClusterAt ?? layout.segmentEnd;
   }
   const packets = state.packets;
-  if (intervalCovered(declared, packets, interval)) return buildIndex(declared, packets, durationSeconds, false, interval, packetMemory);
+  if (intervalCovered(declared, packets, interval)) return buildIndex(declared, packets, endSeconds, false, interval, packetMemory);
   let at = state.at;
   while (at < layout.segmentEnd) {
     const element = state.cluster?.element ?? await validHeader(reader, at, layout.segmentEnd);
@@ -80,14 +80,14 @@ export async function readMatroskaPackets({ readRange, fileSize, portionBytes, l
       cursor = child.end;
       state.cluster.cursor = cursor;
       state.cluster.clusterTicks = clusterTicks;
-      if (intervalCovered(declared, packets, interval)) return buildIndex(declared, packets, durationSeconds, false, interval, packetMemory);
+      if (intervalCovered(declared, packets, interval)) return buildIndex(declared, packets, endSeconds, false, interval, packetMemory);
     }
     if (cursor <= at) throw new Error("Matroska packet walk did not advance.");
     at = element.end ?? cursor;
     state.at = at;
     state.cluster = null;
   }
-  return buildIndex(declared, packets, durationSeconds, true, undefined, packetMemory);
+  return buildIndex(declared, packets, endSeconds, true, undefined, packetMemory);
 }
 
 function paddingForFrame(seconds, duration, count, frame) {
@@ -110,7 +110,7 @@ function intervalCovered(declared, packets, interval) {
   });
 }
 
-function buildIndex(declared, packets, durationSeconds, complete, interval, packetMemory) {
+function buildIndex(declared, packets, endSeconds, complete, interval, packetMemory) {
   const index = new PacketIndex();
   for (const [id, track] of declared) {
     index.declareTrack(id, { type: track.type, codecId: track.codecId, codecRanges: track.codecRanges ?? [], prerollSeconds: track.seekPrerollSeconds ?? 0, reorderDepth: track.reorderDepth ?? 0 });
@@ -120,7 +120,7 @@ function buildIndex(declared, packets, durationSeconds, complete, interval, pack
       if (stream.durationAt(position) === 0 || stream.derivedDurationAt(position)) { needsFollowing = true; break; }
     }
     if (needsFollowing) {
-      const endFor = followingPacketTime(stream, complete ? durationSeconds : null, packetMemory);
+      const endFor = followingPacketTime(stream, complete ? endSeconds : null, packetMemory);
       try { for (let position = 0; position < stream.length; position++) {
         if (stream.durationAt(position) !== 0 && !stream.derivedDurationAt(position)) continue;
         const pts = stream.ptsAt(position), end = endFor(pts);

package/services/media/container/mpeg-elementary-index.js

@@ -28,6 +28,7 @@ export class MpegElementaryIndex {
         nalIndex: track.codecId === "h264" ? new H264ElementaryIndex(track, this.index)
           : track.codecId === "hevc" ? new HevcElementaryIndex(track, this.index) : null,
         picture: null, pendingStart: 0, lastPicture: -1, presentationBase: null, lastDts: null, referencePts: null,
+        lastGroup: -1, groupBegins: false, shownUntil: null,
         audioBytes: Buffer.alloc(0), audioStart: 0, audioPts: null, lastTimestamp: null, clockShift: 0,
         reservoir: new MpegAudioReservoir(), packetCount: 0,
         lastExtension: -1, requiresStamp: false });
@@ -97,6 +98,10 @@ export class MpegElementaryIndex {
       if ((code === 0xb3 || code === 0xb8) && offset > state.lastPicture) {
         if (state.pendingStart === null) state.pendingStart = offset;
       }
+      if (code === 0xb8 && offset > state.lastGroup) {
+        state.lastGroup = offset;
+        state.groupBegins = true;
+      }
       if (code !== 0 || at + 6 > bytes.length || offset <= state.lastPicture) continue;
       if (!(state.track.fps > 0)) throw new Error("MPEG video cadence is not declared.");
       const reference = (bytes[at + 4] << 2) | (bytes[at + 5] >> 6);
@@ -107,7 +112,16 @@ export class MpegElementaryIndex {
       const stamp = stampAt(state, offset);
       if (state.requiresStamp && !stamp) throw new Error("MPEG repeated frames require an explicit following timestamp.");
       state.requiresStamp = false;
+      // `temporal_reference` counts the pictures of one group of pictures in
+      // the order they are shown, from 0 (ISO/IEC 13818-2, 6.3.9), so a new
+      // group shows its first picture where the last one shown ended. A muxer
+      // stamps a PES packet, not every picture: a group whose first picture
+      // came unstamped was placed on the previous group's base, up to a group
+      // earlier, and the index refused to go back: none of four program
+      // streams FFmpeg wrote with more than one group opened (torrent-tv/meta#178).
       if (stamp) state.presentationBase = stamp.pts - reference / state.track.fps;
+      else if (state.groupBegins && state.shownUntil !== null) state.presentationBase = state.shownUntil;
+      state.groupBegins = false;
       if (state.presentationBase === null) throw new Error("MPEG picture has no presentation timestamp.");
       const pts = stamp?.pts ?? state.presentationBase + reference / state.track.fps;
       const dts = stamp?.dts ?? (state.lastDts === null ? pts : state.lastDts + 1 / state.track.fps);
@@ -129,6 +143,7 @@ export class MpegElementaryIndex {
     const { start, ...packet } = state.picture;
     if (!(end > start)) throw new Error("MPEG picture has no bytes.");
     this.index.append(state.track.trackNumber, { ...packet, ranges: addresses(state, start, end) });
+    state.shownUntil = Math.max(state.shownUntil ?? -Infinity, packet.pts + packet.duration);
     state.mappings = state.mappings.filter(mapping => mapping.to > end);
   }
 

package/services/server/wire-outputs.js

@@ -93,6 +93,7 @@ import { audioReadingFor } from "../encode/audio-work-rate.js";
 import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
 import { configurationKeyOf } from "../encode/fingerprint.js";
@@ -345,7 +346,7 @@ export function wireOutputs({
     get encoders() { return parts.encoders; },
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
     productionFailed: (output) => parts.renditions.noteProductionFailed(output),
-    encodersChanged: () => { parts.applyDownloadShare?.(); onEncodersChanged?.(); },
+    encodersChanged: () => { parts.applyDownloadShare?.(); reviseInputCaches(); onEncodersChanged?.(); },
   });
   // How much film is ready in front of the viewers, said; and the spare soundtracks fetched once it is full.
   parts.cushion = new CushionReport({
@@ -1044,10 +1045,25 @@ export function wireOutputs({
     memory: parts.memoryClaimant,
     encodeInputs: parts.encodeInputs,
     indexMemory,
+    // FFmpeg puts its temporary files in /tmp, or where it runs when there is
+    // none — an output directory of the segments.
+    inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: existsSync("/tmp") ? "/tmp" : null },
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger
   });
+  /**
+   * A run reading an original file started or ended, so the disk its cache is
+   * on is divided again — only when what the caches may hold has changed.
+   */
+  let inputCachesDivided = 0;
+  function reviseInputCaches() {
+    const bytes = parts.encodeRuns?.inputCacheBytes() ?? 0;
+    const on = parts.machineBudget?.inputCachesOn;
+    if (!on || bytes === inputCachesDivided) return;
+    inputCachesDivided = bytes;
+    void parts.machineBudget.revise(on, "encoder input caches").catch(error => logger.warn(`input cache budget: ${error.message}`));
+  }
   /**
    * What starting a run costs this output before its first piece is encoded:
    * its own measured open where it has one (`RunCosts.openOf`), else the

package/services/storage/wire.js

@@ -44,6 +44,9 @@ import { availableMemoryBytes } from "./machine-memory.js";
  *   not fit in memory is spilled, so this share decides how much disk is needed.
  * @param {{ held: () => number, allow: (bytes: number) => unknown, root?: string }} [params.wholeFiles] -
  *   Files downloaded whole and kept as files, on the torrent thread as well.
+ * @param {{ held: () => number, root?: string | null }} [params.inputCaches] -
+ *   What FFmpeg's caches of original input hold, and the directory FFmpeg puts
+ *   them in (the segments' disk when none).
  * @param {import("./Diagnostics.js").Diagnostics} [params.diagnostics] - The
  *   evidence. Built where the collectors are, so one object is both registered
  *   here and consulted by them.
@@ -64,6 +67,7 @@ export function wireMachineBudget({
   encodeInputs,
   indexMemory,
   wholeFiles,
+  inputCaches,
   diagnostics,
   diagnosticsRoot = "",
   readFree,
@@ -153,6 +157,25 @@ export function wireMachineBudget({
     });
   }
 
+  // FFMPEG'S CACHE OF WHAT A RUN READ from an original file (`cache:`,
+  // `encode/source-command.js`): a temporary file where FFmpeg puts its own,
+  // as large as what the run has read and at most what it was admitted. Held
+  // while the run lives and given back by nobody else, so it is required in
+  // full and the rest of its disk is divided after it.
+  let inputCachesOn = null;
+  if (typeof inputCaches?.held === "function") {
+    inputCachesOn = inputCaches.root ? deviceOf(inputCaches.root) : segmentsOn;
+    defineDisk(inputCachesOn, inputCaches.root || segmentStore.root);
+    budget.register({
+      name: "encoder input caches",
+      resource: inputCachesOn,
+      held: () => inputCaches.held(),
+      wanted: () => inputCaches.held(),
+      required: () => inputCaches.held(),
+      allow: () => {}
+    });
+  }
+
   let evidenceOn = null;
   if (diagnostics) {
     evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
@@ -188,6 +211,8 @@ export function wireMachineBudget({
       return budget.revise(resource, because);
     },
     segmentBytes: () => segmentBytes,
+    /** The disk FFmpeg's input caches are counted on, or null when none are. */
+    inputCachesOn,
     diagnostics: diagnostics ?? null,
     describe: () => budget.describe()
   };