@torrent-tv/proxy 2.9.82 → 2.9.83

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.83
+
+- **Fix**: Playback died a few seconds in after 2.9.82. The previous muxer wrote each segment under a temporary name and renamed it once complete, so a file appearing WAS a finished segment; the one that takes explicit cut times has no such option and creates the file when writing starts. The route kept judging readiness by existence, so the player was handed a segment that was still being written, rejected it and stopped — while the encoder ran happily ahead, which is exactly how it looked in the field: three segments served, then silence with the transcode at 7.5x. A segment is now considered finished once the next one has been started, or once the run producing it has ended.
+
 ## 2.9.82
 
 - **Fix**: The playlist and the real segments now describe the same thing. On the copy path ffmpeg was given only a target duration and chose its own cut points, while the playlist was built from the container keyframe index — two independent calculations tied together by nothing but the assumption that they agree. They do not: the index is a navigation table and is not obliged to list every keyframe. On a field file it held 1902 while ffmpeg found roughly twice as many and cut twice as often, so segment #876 meant 1:26:50 to the player and about minute 58 to ffmpeg. A seek into the middle landed at the end and the reported duration drifted. ffmpeg now receives the very boundaries the playlist was built from, via the `segment` muxer, which takes the list outright — agreement by construction instead of by luck. Verified on deliberately uneven keyframes: cuts requested at 4.44, 10.36, 16.28, 22.2 and 28.12 s landed exactly there. Two measured details are encoded in the code: those times count from the start of the RUN, not of the file (starting at 12 s and asking for 18 s put the cut at 29.4), and a tolerance absorbs rounding so a boundary recorded a hair late cannot skip to the next keyframe and silently double a segment. MPEG-TS only for now — fMP4 can do this too, but only as self-contained fragments, which removes the shared init segment and the `tfdt` rewriting built around it; that is a separate change and not one to make blind.

package/package.json

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

package/services/hls-session-manager.js

@@ -1868,6 +1868,9 @@ export class HlsSessionManager {
       stdio: ["ignore", "pipe", "pipe"]
     });
     session.ffmpeg = ffmpeg;
+    // Whether this run cuts at times we gave it. Decides how a segment is
+    // judged finished — see getFileStream.
+    session.usesExplicitCuts = Boolean(cutTimes && cutTimes.length > 0);
     session.encodeStartIndex = safeIndex;
     session.pendingRestartIndex = -1;
     session.lastRestartAt = Date.now();
@@ -2491,6 +2494,27 @@ export class HlsSessionManager {
     const isPlaylist = fileName === PLAYLIST_FILE_NAME;
     try {
       await access(filePath);
+
+      // Existing is not the same as finished. The `hls` muxer wrote each
+      // segment to a temporary name and renamed it once complete, so a file
+      // appearing WAS a finished segment. The `segment` muxer has no such
+      // option: the file appears when writing begins. Serving it then hands the
+      // player a truncated segment, which it rejects and then simply stops —
+      // observed as playback dying a few seconds in with the encoder still
+      // running happily ahead. A segment is finished once the NEXT one has been
+      // started, or once the run producing it has ended.
+      if (!isPlaylist && session.usesExplicitCuts) {
+        const index = this.segmentFormat.segmentIndexFromName(fileName);
+        const isLast = index >= Math.max(0, (session.segmentBoundaries?.length ?? 1) - 2);
+        if (!isLast && session.ffmpeg) {
+          const nextPath = path.join(session.dirPath, this.segmentFormat.segmentFileName(index + 1));
+          try {
+            await access(nextPath);
+          } catch {
+            return { kind: "warming-up" };
+          }
+        }
+      }
       // Cold-start: log the first servable SEGMENT of this session exactly once
       // — the time from session-create entry to a playable first segment.
       if (!isPlaylist && !session.firstSegmentLogged) {