@torrent-tv/proxy 2.9.10 → 2.9.12

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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.
+
 ## 2.9.10
 
 - **Fix**: Raised the adaptive-preset speed margin (`PRESET_SPEED_MARGIN` 1.3 → 1.8). The preset benchmark runs at startup with an idle CPU, but during playback ffmpeg competes with in-process WebTorrent (download + SHA1 hashing) and delivery, so real throughput is lower than benchmarked. A 1.3× margin picked a preset that ran near/below realtime under load (e.g. `faster` at ~1.3×) and stalled; 1.8× picks a preset with genuine headroom (e.g. `veryfast`), keeping playback above 1× under real load.

package/package.json

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

package/routes/stream/get.js

@@ -64,6 +64,11 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool
   const releaseFile = torrentPool.acquireFile(torrent, fileIndex);
 
   const range = parseRange(req.headers.range, file.length);
+  // Prioritize the pieces at this read position so a seek (a request at a new
+  // byte offset) downloads first instead of waiting behind the sequential
+  // backlog — this is what caused ~15-18 s stalls when seeking into an
+  // undownloaded region.
+  torrentPool.prioritizeByteRange(torrent, fileIndex, range ? range.start : 0);
   reply.header("Accept-Ranges", "bytes");
   reply.header("Content-Type", "application/octet-stream");
   reply.header("Content-Disposition", `inline; filename*=UTF-8''${encodeURIComponent(file.name)}`);

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/services/torrent-pool.js

@@ -10,6 +10,11 @@ import crypto from "node:crypto";
 import WebTorrent from "webtorrent";
 import { logger } from "../utils/logger.js";
 
+// Bytes ahead of a read position to mark CRITICAL (download-first) on each
+// range request. Big enough to unstick a seek into an undownloaded region,
+// small enough not to make "everything critical" (which defeats prioritization).
+const PRIORITY_WINDOW_BYTES = 8 * 1024 * 1024;
+
 /**
  * Decode a raw torrent source value into the format expected by WebTorrent.
  *
@@ -318,4 +323,45 @@ export class TorrentPool {
       }
     }
   }
+
+  /**
+   * Mark the torrent pieces covering a byte window of a file as CRITICAL, so
+   * WebTorrent downloads them before the rest of the selected file. Called on
+   * every range request: after a seek, the new read position jumps the download
+   * queue instead of waiting behind the sequential backlog (which caused
+   * ~15-18 s stalls when seeking into an undownloaded region).
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {number} fileIndex
+   * @param {number} byteStart - Start offset within the file.
+   * @param {number} [windowBytes] - Bytes ahead of `byteStart` to prioritize.
+   * @returns {void}
+   */
+  prioritizeByteRange(torrent, fileIndex, byteStart, windowBytes = PRIORITY_WINDOW_BYTES) {
+    if (!torrent || typeof torrent.critical !== "function" || !Array.isArray(torrent.files)) {
+      return;
+    }
+    const pieceLength = Number(torrent.pieceLength);
+    if (!Number.isFinite(pieceLength) || pieceLength <= 0) {
+      return;
+    }
+    const file = torrent.files[fileIndex];
+    if (!file) {
+      return;
+    }
+    const fileOffset = Number.isFinite(file.offset) ? file.offset : 0;
+    const safeStart = Math.max(0, Number(byteStart) || 0);
+    const absStart = fileOffset + safeStart;
+    const absEnd = Math.min(fileOffset + file.length - 1, absStart + Math.max(1, windowBytes) - 1);
+    const startPiece = Math.floor(absStart / pieceLength);
+    const endPiece = Math.floor(absEnd / pieceLength);
+    if (endPiece < startPiece) {
+      return;
+    }
+    try {
+      torrent.critical(startPiece, endPiece);
+    } catch {
+      // Best effort — never break streaming because prioritization failed.
+    }
+  }
 }

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)
 }
 
 /**