@torrent-tv/proxy 2.9.11 → 2.9.12

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.9.12
+
+- **Fix**: Eliminate PTS-gap glitches (stutter/freeze on video while audio keeps playing) at start and after seeking, for both transcode modes:
+  - **Branch A — video re-encoded** (`video=libx264`): use a fixed GOP (`-g`/`-keyint_min` = segmentDuration × fps, `-sc_threshold 0`) instead of `-force_key_frames expr:gte(t,n_forced*SEG)`. The old expression broke after a seek because `t` is shifted by `-output_ts_offset`, forcing keyframes at the wrong places and producing segments that did not line up with the playlist grid. A frame-count GOP is offset-independent → every segment is exactly segmentDuration and starts on a keyframe.
+  - **Branch B — video copied** (`video=copy`, only audio transcoded): keep the source's real timestamps with `-copyts` (and accurate seek) instead of relabelling onto a 4 s grid that does not match the source's own keyframe positions. Relabelling was the source of the holes in this mode.
+- **Chore**: Session-start log tags the active branch (`branch=A(reencode,fixed-gop)` / `branch=B(copy,copyts)`) so glitches can be attributed to the right mode.
+- **Fix**: Log timestamps reverted to UTC (`HH:MM:SS.mmm`) so the proxy and browser logs share one timezone and line up exactly when correlated.
+
 ## 2.9.11
 
 - **New**: Seek-aware torrent piece prioritization. On every `/stream` range request the proxy now marks the torrent pieces at the read position **critical** (`TorrentPool.prioritizeByteRange` → `torrent.critical`, ~8 MB window). After a seek, ffmpeg opens the input at a new byte offset; previously those pieces waited behind the sequential download backlog, so seeking into an undownloaded region stalled ~15-18 s while the proxy fetched data. Now the seek position jumps the download queue.

package/package.json

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

package/services/hls-session-manager.js

@@ -616,6 +616,9 @@ export class HlsSessionManager {
       `transcode ${sessionId} start "${logName}" ` +
         `video=${transcodeVideo ? `${this.videoEncoder.name}${softwarePreset ? `/${softwarePreset}` : ""}` : "copy"} ` +
         `audio=${transcodeAudio ? "aac" : "copy"} ` +
+        // Branch tag for log correlation: A = video re-encode (fixed GOP, grid
+        // aligned, ts-offset); B = video copy (cut at source keyframes, copyts).
+        `branch=${transcodeVideo ? "A(reencode,fixed-gop)" : "B(copy,copyts)"} ` +
         `${sourceWidth && sourceHeight ? `src=${sourceWidth}x${sourceHeight} ` : ""}` +
         `duration=${hasDuration ? formatSeconds(durationSeconds) : "unknown"} segments=${segmentCount}`
     );
@@ -740,14 +743,27 @@ export class HlsSessionManager {
       args.push(...this.videoEncoder.inputArgs);
     }
     if (startSeconds > 0) {
-      // Fast keyframe-level seek before -i (skips decoding earlier frames).
-      args.push("-ss", String(startSeconds));
+      // Accurate seek before -i (decodes from the preceding keyframe and trims
+      // to the exact point), so the first output frame is exactly at startSeconds.
+      args.push("-accurate_seek", "-ss", String(startSeconds));
     }
     args.push("-i", session.inputUrl);
-    if (startSeconds > 0) {
-      // Keep output timestamps on the original timeline so video.currentTime
-      // matches the requested position.
-      args.push("-output_ts_offset", String(startSeconds));
+    if (session.transcodeVideo) {
+      // Branch A (re-encode): fixed GOP makes keyframes land exactly on the
+      // segment grid; relabel output onto the original timeline so segment N
+      // carries PTS = N × segmentDuration.
+      if (startSeconds > 0) {
+        args.push("-output_ts_offset", String(startSeconds));
+      }
+    } else {
+      // Branch B (video copied — only audio is transcoded): we cannot insert
+      // keyframes, so segments are cut at the source's own keyframes. Keep the
+      // source's real timestamps (`-copyts`) instead of relabelling, so the
+      // copied frames stay continuous across segment boundaries and seek-restarts
+      // (relabelling to a 4 s grid that does not match the real keyframe times is
+      // exactly what produced the PTS holes / glitches). Audio is transcoded on
+      // the same timeline.
+      args.push("-copyts");
     }
     args.push(
       "-map",

package/services/hwaccel.js

@@ -90,7 +90,17 @@ export function softwareDescriptor() {
         "-crf", SOFTWARE_CRF,
         "-threads", String(CPU_THREADS),
         "-pix_fmt", "yuv420p",
-        ...keyFrameArgs(segmentDurationSec)
+        // Fixed GOP: a keyframe exactly every (segmentDurationSec × fps) frames,
+        // scene-cut keyframes disabled. This is frame-count based, so it is
+        // independent of the PTS offset used on seek-restart — every HLS segment
+        // is exactly segmentDurationSec long and starts on a keyframe, so segment
+        // boundaries line up with the synthetic playlist with no gaps. (The old
+        // `-force_key_frames expr:gte(t,n_forced*SEG)` broke after a seek because
+        // `t` is offset by `-output_ts_offset`, forcing keyframes at the wrong
+        // places.)
+        "-g", String(segmentDurationSec * TRANSCODE_FPS),
+        "-keyint_min", String(segmentDurationSec * TRANSCODE_FPS),
+        "-sc_threshold", "0"
       ];
     }
   };

package/utils/logger.js

@@ -10,13 +10,14 @@ import chalk from "chalk";
 const PREFIX = "[proxy-client]";
 
 /**
- * Return the current time as a compact ISO-8601 string, e.g. `12:34:56.789`.
- * Uses only the time portion to keep log lines short.
+ * Return the current time as a compact ISO-8601 (UTC) string, e.g.
+ * `12:34:56.789`. UTC is used deliberately so proxy and browser logs share the
+ * same timezone and line up exactly when correlating them.
  *
  * @returns {string}
  */
 function ts() {
-  return new Date().toISOString().slice(11, 23); // "HH:MM:SS.mmm"
+  return new Date().toISOString().slice(11, 23); // "HH:MM:SS.mmm" (UTC)
 }
 
 /**