@torrent-tv/proxy 2.9.43 → 2.9.45

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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.
+
 ## 2.9.43
 
 - **Fix**: Torrents stalled at the metadata/download stage on WebTorrent 3.x — the adaptive upload throttle dropped the client-wide limit to `0` whenever no file had an active reader (e.g. the window before the first read is acquired). In WebTorrent 3.x `throttleUpload(0)` blocks the ENTIRE swarm exchange client-wide — even peer connections and DOWNLOAD — not just seeding (verified: `throttleUpload(0)` → 0 peers, 0 download; `throttleUpload(8KB/s)` → peers connect, multi-MB/s download). The idle branch now returns a minimal keep-alive floor (`UPLOAD_IDLE_FLOOR_BYTES` = 8 KB/s) instead of 0; still effectively no seeding, but the swarm stays alive.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.9.43",
+  "version": "2.9.45",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {
@@ -29,7 +29,8 @@
     "franc": "^6.2.0",
     "get-port": "^7.1.0",
     "node-datachannel": "^0.32.0",
-    "webtorrent": "^3.0.16",
+    "uint8-util": "2.2.6",
+    "webtorrent": "2.8.5",
     "ws": "^8.18.2"
   }
 }

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