@torrent-tv/proxy 2.9.44 → 2.9.46

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.9.46
+
+- **New**: `getFileStats` now reports `resumeNeededBytes` / `resumeDownloadedBytes` — the bytes still to download in the 16 MB window ahead of the file's current read position (tracked per file by `prioritizeByteRange`, cleared on torrent removal), counted byte-accurately including partial pieces. Lets the browser show how much is left to download and the time to resume while buffering.
+
+## 2.9.45
+
+- **New**: HLS transcode output switched from MPEG-TS (`.ts`) to **fMP4/CMAF** (`.m4s` segments + a shared `init.mp4`). Codec parameter sets (SPS/PPS) now live once in the init segment (referenced by `#EXT-X-MAP`) instead of being repeated in every segment. Benefits: (1) hardware encoders that do not repeat parameter sets — notably the CM4 / HA-Yellow `h264_v4l2m2m` — produce independently-usable segments (on `.ts` the segments after the first lacked SPS/PPS → "non-existing PPS", which is why v4l2m2m was rejected); (2) lower container overhead. The synthetic VOD playlist now emits `#EXT-X-VERSION:7` + `#EXT-X-MAP`; each seek-restart run rewrites `init.mp4`, so `getFileStream` caches and serves the FIRST init for the whole session — it is codec-config-only and position-independent (verified: a single init cleanly decodes segments produced by a later seek-restart run). Raised v4l2m2m `-num_capture_buffers` to 32 (the default 4 deadlocks / drops frames on the CM4). **Verified**: server-side clean decode of the synthetic playlist across seek-restart runs; end-to-end playback **and seek** in hls.js 1.6.16. **Still needs**: verification on native iOS HLS (Safari fMP4) before relying on it. NOTE: v4l2m2m still emits a residual no-picture access unit that the strict startup test rejects, so it continues to fall back to software for now (no regression); fMP4 removes the SPS/PPS blocker — the remaining quirk is separate.
+
 ## 2.9.44
 
 - **Fix**: Roll back to WebTorrent **2.8.5** (pinned) — 3.x introduced two regressions that broke downloading. (1) `torrent.downloaded`/`file.downloaded`/`file.progress` throw on a `deselect`-ed null piece (worked around in 2.9.43). (2) Worse: the internal piece picker itself throws `Cannot read properties of null (reading 'reserve'/'missing')` when it tries to request a block from a piece our seek prioritization (`prioritizeByteRange` `deselect`) removed — download freezes dead after a seek (field-observed: file stuck at ~51%, `down=0`, picker crashing every second). 2.8.5 is the known-good version: `select`/`deselect`/`critical` and the byte getters all work (verified — add, multi-file download, and the full deselect+critical seek pattern run with zero crashes on 2.8.5). Also pinned **`uint8-util` 2.2.6**: 2.8.5's own range is `^2.2.5`, which *allows* the incompatible 2.3.x that a fresh global install pulled (the original `arr2hex` crash), so the transitive version must be forced back — webtorrent dedupes to 2.2.6 while sub-deps that need 2.3.x keep their own nested copy. The 2.9.43 null-safe getter helpers are now redundant (2.8.5 getters never throw) but left in as harmless defensive code.

package/package.json

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

package/services/hls-session-manager.js

@@ -31,7 +31,12 @@ import {
 } from "./ffmpeg-banner.js";
 
 const PLAYLIST_FILE_NAME = "index.m3u8";
-const SEGMENT_FILE_NAME_PATTERN = /^segment-\d{5}\.ts$/;
+// fMP4 (CMAF) segments: SPS/PPS live once in the init segment, so every media
+// segment is small and hardware encoders that do not repeat parameter sets
+// (e.g. v4l2m2m) still produce independently-usable segments. The init segment
+// is referenced by `#EXT-X-MAP` and fetched once by the player.
+const SEGMENT_INIT_FILE_NAME = "init.mp4";
+const SEGMENT_FILE_NAME_PATTERN = /^segment-\d{5}\.m4s$/;
 const CLEANUP_INTERVAL_MS = 30_000;
 const DEFAULT_SEGMENT_DURATION_SEC = 4;
 // How many segments ahead of the current encode head a missing-segment request
@@ -203,18 +208,22 @@ function isSafeSessionId(value) {
  * @returns {boolean}
  */
 function isSafeFileName(fileName) {
-  return fileName === PLAYLIST_FILE_NAME || SEGMENT_FILE_NAME_PATTERN.test(fileName);
+  return (
+    fileName === PLAYLIST_FILE_NAME ||
+    fileName === SEGMENT_INIT_FILE_NAME ||
+    SEGMENT_FILE_NAME_PATTERN.test(fileName)
+  );
 }
 
 /**
  * Extract the zero-based segment index from a segment file name.
  * Returns -1 when the name is not a valid segment file.
  *
- * @param {string} fileName - e.g. "segment-00012.ts"
+ * @param {string} fileName - e.g. "segment-00012.m4s"
  * @returns {number}
  */
 function segmentIndexFromName(fileName) {
-  const match = /^segment-(\d{5})\.ts$/.exec(fileName);
+  const match = /^segment-(\d{5})\.m4s$/.exec(fileName);
   if (!match) {
     return -1;
   }
@@ -1000,16 +1009,20 @@ export class HlsSessionManager {
     }
     const lines = [
       "#EXTM3U",
-      "#EXT-X-VERSION:3",
+      // Version 7: required for fMP4 media segments + `#EXT-X-MAP`.
+      "#EXT-X-VERSION:7",
       `#EXT-X-TARGETDURATION:${Math.ceil(maxDuration)}`,
       "#EXT-X-MEDIA-SEQUENCE:0",
       "#EXT-X-PLAYLIST-TYPE:VOD",
-      "#EXT-X-INDEPENDENT-SEGMENTS"
+      "#EXT-X-INDEPENDENT-SEGMENTS",
+      // The fMP4 init segment (codec config / SPS/PPS). Fetched once; applies to
+      // every media segment below.
+      `#EXT-X-MAP:URI="${SEGMENT_INIT_FILE_NAME}"`
     ];
     for (let index = 0; index < count; index += 1) {
       const duration = Math.max(0.1, boundaries[index + 1] - boundaries[index]);
       lines.push(`#EXTINF:${duration.toFixed(6)},`);
-      lines.push(`segment-${String(index).padStart(5, "0")}.ts`);
+      lines.push(`segment-${String(index).padStart(5, "0")}.m4s`);
     }
     lines.push("#EXT-X-ENDLIST");
     return `${lines.join("\n")}\n`;
@@ -1148,7 +1161,7 @@ export class HlsSessionManager {
     }
     const indices = [];
     for (const name of names) {
-      const match = /^segment-(\d{5})\.ts$/.exec(name);
+      const match = /^segment-(\d{5})\.m4s$/.exec(name);
       if (match) {
         indices.push(parseInt(match[1], 10));
       }
@@ -1161,7 +1174,7 @@ export class HlsSessionManager {
     let bytes = 0;
     try {
       for (const index of completed) {
-        const st = await stat(path.join(session.dirPath, `segment-${String(index).padStart(5, "0")}.ts`));
+        const st = await stat(path.join(session.dirPath, `segment-${String(index).padStart(5, "0")}.m4s`));
         bytes += st.size;
       }
     } catch {
@@ -1466,10 +1479,18 @@ export class HlsSessionManager {
       "0",
       "-hls_flags",
       "independent_segments+temp_file",
+      // fMP4 (CMAF) segments: codec config goes once into the init segment,
+      // referenced by `#EXT-X-MAP`. Each seek-restart run rewrites init.mp4, but
+      // it is codec-config only (position-independent), so getFileStream caches
+      // and serves the first one for the whole session.
+      "-hls_segment_type",
+      "fmp4",
+      "-hls_fmp4_init_filename",
+      SEGMENT_INIT_FILE_NAME,
       "-start_number",
       String(safeIndex),
       "-hls_segment_filename",
-      "segment-%05d.ts",
+      "segment-%05d.m4s",
       // ffmpeg writes its own playlist here; we ignore it and serve the
       // synthetic VOD playlist instead (see getFileStream).
       PLAYLIST_FILE_NAME
@@ -1779,6 +1800,25 @@ export class HlsSessionManager {
       };
     }
 
+    // The fMP4 init segment (referenced by #EXT-X-MAP). It is codec-config only
+    // and position-independent, but each seek-restart run REWRITES init.mp4, so
+    // cache the FIRST one and always serve that — otherwise the init the player
+    // fetched could differ from a later run's, breaking playback after a seek.
+    if (fileName === SEGMENT_INIT_FILE_NAME) {
+      if (session.initBytes) {
+        return { kind: "file", stream: Readable.from([session.initBytes]), contentType: "video/mp4", isPlaylist: false };
+      }
+      try {
+        const bytes = await readFile(path.join(session.dirPath, SEGMENT_INIT_FILE_NAME));
+        session.initBytes = bytes;
+        return { kind: "file", stream: Readable.from([bytes]), contentType: "video/mp4", isPlaylist: false };
+      } catch {
+        // Not produced yet — the encode run started at session creation writes
+        // it early; the caller long-polls until it appears.
+        return { kind: "warming-up" };
+      }
+    }
+
     const filePath = path.join(session.dirPath, fileName);
     try {
       await access(filePath);
@@ -1799,7 +1839,7 @@ export class HlsSessionManager {
         contentType:
           fileName === PLAYLIST_FILE_NAME
             ? "application/vnd.apple.mpegurl"
-            : "video/mp2t",
+            : "video/mp4",
         isPlaylist: fileName === PLAYLIST_FILE_NAME
       };
     } catch (_error) {

package/services/hwaccel.js

@@ -303,6 +303,10 @@ function v4l2m2mDescriptor() {
         "-vf",
         `scale=${w}:${h}:force_original_aspect_ratio=decrease:force_divisible_by=2,fps=${outFps},format=yuv420p`,
         "-c:v", "h264_v4l2m2m",
+        // More capture buffers than the default 4 — the default deadlocks /
+        // drops frames on the CM4 encoder ("All capture buffers returned to
+        // userspace").
+        "-num_capture_buffers", "32",
         "-b:v", "3M",
         "-g", String(outFps * segmentDurationSec),
         ...keyFrameArgs(segmentDurationSec)
@@ -438,7 +442,7 @@ function buildEncoderTestArgs(descriptor, segmentDurationSec, outDir) {
       encode = ["-c:v", "h264_nvenc", "-preset", "p4", "-cq", "24", "-pix_fmt", "yuv420p", ...kf];
       break;
     case "v4l2m2m":
-      encode = ["-pix_fmt", "yuv420p", "-c:v", "h264_v4l2m2m", "-b:v", "3M", "-g", String(TRANSCODE_FPS * segmentDurationSec), ...kf];
+      encode = ["-pix_fmt", "yuv420p", "-c:v", "h264_v4l2m2m", "-num_capture_buffers", "32", "-b:v", "3M", "-g", String(TRANSCODE_FPS * segmentDurationSec), ...kf];
       break;
     default:
       encode = ["-c:v", "libx264", "-preset", "ultrafast", "-pix_fmt", "yuv420p", ...kf];
@@ -450,7 +454,10 @@ function buildEncoderTestArgs(descriptor, segmentDurationSec, outDir) {
     "-hls_time", String(segmentDurationSec),
     "-hls_list_size", "0",
     "-hls_flags", "independent_segments",
-    "-hls_segment_filename", path.join(outDir, "seg-%03d.ts"),
+    // fMP4 (CMAF) — matches the runtime pipeline (hls-session-manager).
+    "-hls_segment_type", "fmp4",
+    "-hls_fmp4_init_filename", "init.mp4",
+    "-hls_segment_filename", path.join(outDir, "seg-%03d.m4s"),
     path.join(outDir, "index.m3u8")
   ];
   return [...pre, ...source, ...encode, ...hlsOut];
@@ -469,24 +476,24 @@ function buildEncoderTestArgs(descriptor, segmentDurationSec, outDir) {
 async function verifySegmentsDecodeCleanly(ffmpegBin, outDir) {
   let files;
   try {
-    files = readdirSync(outDir).filter((n) => /^seg-\d+\.ts$/.test(n)).sort();
+    files = readdirSync(outDir).filter((n) => /^seg-\d+\.m4s$/.test(n));
   } catch {
     return false;
   }
   if (files.length < 2) {
     return false;
   }
-  for (const file of files) {
-    const result = await runFfmpeg(
-      ffmpegBin,
-      ["-hide_banner", "-loglevel", "error", "-i", path.join(outDir, file), "-f", "null", "-"],
-      8000
-    );
-    if (result.code !== 0 || result.stderr.trim().length > 0) {
-      return false;
-    }
-  }
-  return true;
+  // fMP4: parameter sets (SPS/PPS) live in init.mp4, not in each segment.
+  // Decode the whole playlist (ffmpeg's own, which references init.mp4 via
+  // #EXT-X-MAP), so every segment is exercised together with the init. Any
+  // corrupt / non-conformant segment (e.g. some V4L2 M2M builds emit a stray
+  // no-picture access unit) surfaces as a decode error here.
+  const result = await runFfmpeg(
+    ffmpegBin,
+    ["-hide_banner", "-loglevel", "error", "-i", path.join(outDir, "index.m3u8"), "-f", "null", "-"],
+    12000
+  );
+  return result.code === 0 && result.stderr.trim().length === 0;
 }
 
 /**

package/services/torrent-pool.js

@@ -295,6 +295,16 @@ export class TorrentPool {
    */
   #lastAccess = new Map();
 
+  /**
+   * Last byte offset each active reader is streaming from, keyed by torrent then
+   * fileIndex. Set by prioritizeByteRange on every /stream range request; read by
+   * getFileStats to report how much of the window ahead of the read head is still
+   * to download — the "amount left to resume" shown while buffering.
+   *
+   * @type {Map<import("webtorrent").Torrent, Map<number, number>>}
+   */
+  #readPositionByTorrent = new Map();
+
   /** Global disk cap in bytes (0 = disabled). */
   #maxDiskBytes = 0;
 
@@ -700,6 +710,7 @@ export class TorrentPool {
     }
     this.fileUsageByTorrent.delete(torrent);
     this.#lastAccess.delete(torrent);
+    this.#readPositionByTorrent.delete(torrent);
     const name = typeof torrent.name === "string" ? torrent.name : "(unknown)";
     try {
       torrent.destroy({ destroyStore: true }, () => {
@@ -743,6 +754,14 @@ export class TorrentPool {
 
     const header = this.#getHeaderRangeProgress(torrent, file);
 
+    // Bytes still to download in the window ahead of where this file is being
+    // read — "how much left to resume". Null until a read position is known.
+    const readPositions = this.#readPositionByTorrent.get(torrent);
+    const readByteStart = readPositions ? readPositions.get(fileIndex) : undefined;
+    const resume = typeof readByteStart === "number"
+      ? this.#getResumeWindowProgress(torrent, file, readByteStart)
+      : null;
+
     // Null-safe downloaded/progress (webtorrent's own getters throw on a
     // deselected null piece — see fileDownloadedBytes).
     const fileLength = typeof file.length === "number" ? file.length : 0;
@@ -753,6 +772,9 @@ export class TorrentPool {
       fileProgress: fileLength > 0 ? Math.max(0, Math.min(1, fileDownloaded / fileLength)) : 0,
       fileDownloaded,
       fileLength,
+      // Resume window (ahead of the read head): bytes needed vs downloaded.
+      resumeNeededBytes: resume ? resume.totalBytes : null,
+      resumeDownloadedBytes: resume ? resume.downloadedBytes : null,
       // Phase-1 progress: how much of the header/index region (the bytes the
       // codec probe needs before transcoding can start) is downloaded. Counted
       // by whole pieces from the torrent bitfield, so it advances coarsely
@@ -808,6 +830,45 @@ export class TorrentPool {
     return { totalBytes, downloadedBytes };
   }
 
+  /**
+   * Count, by whole torrent pieces, how many bytes of the window AHEAD of the
+   * current read position are downloaded — i.e. how much is still to download
+   * before playback can continue from that point. Mirrors
+   * {@link #getHeaderRangeProgress}, for the moving read head.
+   *
+   * @param {import("webtorrent").Torrent} torrent
+   * @param {import("webtorrent").TorrentFile} file
+   * @param {number} readByteStart - Byte offset within the file the reader is at.
+   * @returns {{ totalBytes: number, downloadedBytes: number } | null}
+   */
+  #getResumeWindowProgress(torrent, file, readByteStart) {
+    const pieceLength = Number(torrent?.pieceLength);
+    const bitfield = torrent?.bitfield;
+    const fileLength = Number(file?.length);
+    if (
+      !Number.isFinite(pieceLength) || pieceLength <= 0 ||
+      !bitfield || typeof bitfield.get !== "function" ||
+      !Number.isFinite(fileLength) || fileLength <= 0
+    ) {
+      return null;
+    }
+    const fileOffset = Number.isFinite(file.offset) ? file.offset : 0;
+    const windowStart = Math.max(0, Math.min(Number(readByteStart) || 0, fileLength - 1));
+    const windowEnd = Math.min(fileLength - 1, windowStart + PRIORITY_WINDOW_BYTES - 1);
+    const firstPiece = Math.floor((fileOffset + windowStart) / pieceLength);
+    const lastPiece = Math.floor((fileOffset + windowEnd) / pieceLength);
+    // Byte-accurate: count the PARTIAL progress of in-progress pieces (not whole
+    // pieces), so "amount left" moves smoothly instead of jumping by a whole
+    // piece (8 MB here) at a time.
+    let totalBytes = 0;
+    let downloadedBytes = 0;
+    for (let piece = firstPiece; piece <= lastPiece; piece += 1) {
+      totalBytes += pieceLength;
+      downloadedBytes += pieceDownloadedBytes(torrent, piece);
+    }
+    return { totalBytes, downloadedBytes };
+  }
+
   /**
    * Pre-fetch the leading and trailing bytes of a torrent file so that
    * WebTorrent prioritises the pieces that contain file headers and footers.
@@ -967,6 +1028,16 @@ export class TorrentPool {
     const fileEndPiece = Math.floor((fileOffset + fileLength - 1) / pieceLength);
 
     const safeStart = Math.max(0, Number(byteStart) || 0);
+
+    // Remember where this file is being read from, so getFileStats can report the
+    // download progress of the window ahead of the read head (resume amount).
+    let readPositions = this.#readPositionByTorrent.get(torrent);
+    if (!readPositions) {
+      readPositions = new Map();
+      this.#readPositionByTorrent.set(torrent, readPositions);
+    }
+    readPositions.set(fileIndex, safeStart);
+
     const absStart = fileOffset + safeStart;
     const playheadPiece = Math.floor(absStart / pieceLength);
     const absWindowEnd = Math.min(