@torrent-tv/proxy 2.9.5 → 2.9.7

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.9.7
+
+- **Fix**: `playback-planner` retries the codec probe while the file header is still downloading and no longer caches an **empty** probe result. Previously a transient empty probe (common for a later file in a multi-file torrent whose pieces arrive late) was cached permanently, so the file was mis-planned as directly playable forever — an unsupported video codec (e.g. xvid) got copied and played as a **black screen**. The probe now retries (up to 60 s) until at least one codec is detected, and only a successful detection is cached.
+
+## 2.9.6
+
+- **Fix**: `probeInputDurationSeconds` now returns as soon as ffmpeg prints the container header (`Duration:`) instead of letting `-f null -` decode the whole stream until the 8 s timeout. Transcode-session creation was wasting ~8.6 s per session on this redundant decode (the duration was already available from the header, and `playback-plan` had probed it moments earlier). Cuts session-creation latency from ~9.7 s to ~1 s.
+- **New**: `GET /api/transcode-sessions/:id/progress` now includes `segmentDurationSec`, so the browser can show progress toward the first segment (the only thing it waits for before playback) instead of a percentage of the whole-file transcode.
+
 ## 2.9.5
 
 - **Fix**: Segment files are now read with a 4 MB `highWaterMark` (`hls-session-manager.js` `getFileStream`) so the body is delivered in few, large chunks. On a busy ARM host the in-process WebTorrent hashing starves the Node event loop in bursts while the first segments are served; reading in fewer iterations cuts the time lost between chunks (the first segment previously transferred in ~79 × 43 KB reads spaced ~610 ms apart).

package/CLAUDE.md

@@ -50,9 +50,14 @@ Linux-only host (e.g. POSIX-only signals must degrade elsewhere).
 ## Changelog
 
 Every behavioural change must be recorded in `CHANGELOG.md` — add an entry under
-a new `## <version>` heading at the top (the next patch version that
-`npm run patch` will publish), following the existing
-`- **New**/**Fix**/**Chore**:` format. See the parent `../CLAUDE.md`.
+a new `## <version>` heading at the top, following the existing
+`- **New**/**Fix**/**Chore**:` format.
+
+**Do NOT edit `package.json` version.** `npm run patch`/`minor` runs `npm
+version …` which bumps it. Write the CHANGELOG entry at the version that bump
+will produce: **current `package.json` version + 1 patch** (or + 1 minor).
+Accumulate bullets into that single pending entry until it's published. See the
+parent `../CLAUDE.md`.
 
 ## Release
 

package/package.json

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

package/services/hls-session-manager.js

@@ -277,6 +277,17 @@ async function probeInputDurationSeconds(ffmpegBin, inputUrl) {
     }, 8_000);
     ffmpeg.stderr.on("data", (chunk) => {
       stderr += String(chunk);
+      // ffmpeg prints the container header ("Duration:") almost immediately,
+      // long before it decodes anything. Bail as soon as we have it instead of
+      // letting `-f null -` decode the whole stream until the 8 s timeout.
+      const duration = parseFfmpegDurationSeconds(stderr);
+      if (duration != null) {
+        clearTimeout(timeoutId);
+        if (!ffmpeg.killed) {
+          ffmpeg.kill("SIGTERM");
+        }
+        finish(duration);
+      }
     });
     ffmpeg.on("error", () => {
       clearTimeout(timeoutId);
@@ -983,6 +994,10 @@ export class HlsSessionManager {
       remainingSeconds: session.progress.remainingSeconds,
       warmupPercent,
       warmupRemainingSeconds,
+      // Segment length, so the browser can show progress toward the FIRST
+      // segment (the only thing it waits for before playback starts) instead
+      // of a percentage of the whole-file transcode.
+      segmentDurationSec: this.segmentDurationSec,
       speed: session.progress.speed,
       updatedAt: session.progress.updatedAt,
       error: session.state === "failed" ? session.lastError : ""

package/services/playback-planner.js

@@ -97,6 +97,18 @@ function probeStreamCodecs({ ffmpegBin, inputUrl, userAgent = "", timeoutMs = 8_
   });
 }
 
+/**
+ * Resolve after a given number of milliseconds.
+ *
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 /**
  * Build the direct stream URL for a source file served by the local proxy.
  *
@@ -198,28 +210,34 @@ export function createPlaybackPlanner({
         return plan;
       }
 
-      // Pre-fetch file edges (head + tail) before probing so that WebTorrent
-      // has the MOOV atom (or MKV EBML headers) ready for ffprobe.
-      // Without this, ffprobe times out on fresh torrents whose MOOV sits at
-      // the end of the file and hasn't been downloaded yet.
+      // Pre-fetch file edges (head + tail), then probe — retrying while the
+      // file header is still downloading. In a multi-file torrent the pieces
+      // for a given file arrive unevenly, so the first probe can return empty
+      // codecs. A transient empty probe must NOT be cached: otherwise the wrong
+      // plan (file treated as directly playable) sticks permanently for this
+      // file, and an unsupported codec like xvid gets copied → black video.
       await torrentPool.prefetchFileEdges(torrent, fileIndex);
+      let probe = await probeStreamCodecs({ ffmpegBin, inputUrl: directUrl, userAgent });
+      const probeDeadline = Date.now() + 60_000;
+      let attempt = 0;
+      while (
+        probe.audioCodec.length === 0 &&
+        probe.videoCodec.length === 0 &&
+        Date.now() < probeDeadline
+      ) {
+        attempt += 1;
+        await delay(Math.min(3_000, 500 + attempt * 250));
+        await torrentPool.prefetchFileEdges(torrent, fileIndex);
+        probe = await probeStreamCodecs({ ffmpegBin, inputUrl: directUrl, userAgent });
+      }
+      const { audioCodec, videoCodec, container, durationSeconds } = probe;
+      const codecsDetected = audioCodec.length > 0 || videoCodec.length > 0;
 
-      const { audioCodec, videoCodec, container, durationSeconds } = await probeStreamCodecs({
-        ffmpegBin,
-        inputUrl: directUrl,
-        userAgent
-      });
-
-      // Only transcode when the codec is known AND not natively supported.
-      // When ffprobe cannot detect the codec (e.g. the torrent has just started
-      // downloading and the MOOV atom at the end of the MP4 is not yet available),
-      // fall back to "direct" so the browser can attempt native playback.  The
-      // browser-side loading pipeline already has its own transcode fallback.
+      // `mode` is advisory only (audio-codec based). The browser makes the
+      // authoritative decision independently per stream via canPlayType /
+      // mediaCapabilities, transcoding only what it cannot play.
       const requiresTranscode = audioCodec.length > 0 && !DIRECT_AUDIO_CODECS.has(audioCodec);
       const plan = {
-        // `mode` is advisory only (audio-codec based).  The browser makes the
-        // authoritative decision independently per stream via canPlayType /
-        // mediaCapabilities, transcoding only what it cannot play.
         mode: requiresTranscode ? "hls" : "direct",
         directUrl,
         reason: requiresTranscode ? "audio-codec-transcode-required" : "audio-codec-supported",
@@ -228,7 +246,12 @@ export function createPlaybackPlanner({
         container,
         durationSeconds
       };
-      cache.set(cacheKey, plan);
+      // Only cache a plan whose codecs were actually detected. An empty probe is
+      // a "header not downloaded yet" signal, not a valid result — caching it
+      // would permanently mis-plan the file.
+      if (codecsDetected) {
+        cache.set(cacheKey, plan);
+      }
       return plan;
     }
   };