@torrent-tv/proxy 2.97.21 → 2.97.23

package/package.json

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

package/services/encode/EncodeRun.js

@@ -123,6 +123,8 @@ export class EncodeRun {
    */
   #pendingAtStop = null;
   #closedTimings = new Map();
+  /** When the encoder named each closed piece on its channel, until it is published. */
+  #namedAt = new Map();
   #publicationError = null;
   #publicationCode = null;
   #inputTruncated = false;
@@ -622,6 +624,7 @@ export class EncodeRun {
       if (name.length === 0) {
         continue;
       }
+      this.#namedAt.set(name, this.now());
       if (this.#publicationError) continue;
       if (this.#stopping) {
         // Flushed by our stop. Never published; it tells where the piece closed
@@ -681,7 +684,8 @@ export class EncodeRun {
       // name a request can actually ask for.
       let served;
       try {
-        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null, { tentative });
+        served = this.onClosed(name, following, this.#closedTimings.get(name) ?? null,
+          { tentative, namedAt: this.#namedAt.get(name) ?? null });
       } catch (error) {
         if (quiet) {
           // A piece closed before our stop that cannot be proved whole is not
@@ -702,7 +706,10 @@ export class EncodeRun {
       } finally {
         // A piece not proved whole on its own keeps its timing for the file
         // after it.
-        if (!tentative || served) this.#closedTimings.delete(name);
+        if (!tentative || served) {
+          this.#closedTimings.delete(name);
+          this.#namedAt.delete(name);
+        }
       }
 
       if (!served) return false;

package/services/encode/EncodeRuns.js

@@ -1121,7 +1121,7 @@ export class EncodeRuns {
       // from it — a re-encoded picture, or sound served as its own output. Such
       // a piece is published on its own line (torrent-tv/meta#178).
       publishesAlone: this.publishesAlone(session),
-      onClosed: (name, following, timing, { tentative = false } = {}) => {
+      onClosed: (name, following, timing, { tentative = false, namedAt = null } = {}) => {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
@@ -1131,6 +1131,8 @@ export class EncodeRuns {
         if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         const address = session.outputKey ?? "";
+        // Read before anything rewrites it: when the encoder finished it.
+        const writtenAt = this.#host.segmentFiles.writtenAtOf?.(address, name) ?? null;
         const fmp4 = admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only";
         // The first piece of a run that read the picture from its keyframe:
         // its leading pictures are the ones the run before made, or none.
@@ -1157,6 +1159,14 @@ export class EncodeRuns {
         const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         this.#leadingByOutput.get(address)?.delete(index);
+        // WHERE A LATE PIECE'S TIME WENT: the encoder writing it, this process
+        // getting to its name, or its publication waiting for the file after
+        // it. A piece 5.7 s apart from the one before stopped a viewer inside a
+        // running run, and nothing said which (torrent-tv/meta#178).
+        const since = at => (Number.isFinite(at) ? `+${Math.round(at - run.startedAt)}ms` : "unknown");
+        this.#host.logger.info(`encode-run #${run.from}..#${run.to} on ${address}: #${index} written by the encoder ${since(writtenAt)}, ` +
+          `named ${since(namedAt)}, published ${since(run.now())} ` +
+          (following ? `when ${following} closed` : tentative ? "on its own" : "at the run's end"));
         return published;
 
       },

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/storage/segment-store/SegmentStore.js

@@ -594,6 +594,23 @@ export class SegmentStore {
     return readFileSync(path.join(this.#root, directoryNameFor(key), makingName));
   }
 
+  /**
+   * When the encoder last wrote a file it has closed under its working name,
+   * on the kernel's clock and so apart from when this process got to it; null
+   * when it is not there.
+   *
+   * @param {string} key
+   * @param {string} makingName
+   * @returns {number | null}
+   */
+  writtenAtOf(key, makingName) {
+    try {
+      return statSync(path.join(this.#root, directoryNameFor(key), makingName)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * The media intervals a stored piece holds, read once from its bytes and kept
    * with them, or undefined where its format reads none or it is not here.