@torrent-tv/proxy 2.9.6 → 2.9.9

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2.9.8
+
+- **Fix**: Software (libx264) video transcode is much faster on weak ARM hosts, so playback keeps up with realtime: encode uses all CPU cores (`-threads`), and the scaler **never upscales** — the target box is capped to the source size via `min(W,iw)`/`min(H,ih)`, so a small source (e.g. 720x400) is encoded at its own resolution instead of being scaled up to the viewport (far fewer pixels).
+- **New**: Adaptive software preset (preset auto-benchmark). At startup the proxy benchmarks libx264 presets (`fast`→`ultrafast`) on this host and records encode throughput (pixels/sec). Per stream, `hls-session-manager` picks the **highest-quality preset that still encodes the actual (source-capped) output resolution faster than realtime** with a safety margin, falling back to `ultrafast`. This maximises quality without dropping below 1× (which causes stalls). Logged as `video=libx264/<preset>` at session start.
+- **New**: The input probe (`probeInputMediaInfo`, formerly `probeInputDurationSeconds`) now also extracts the source video resolution from the container header (used by the adaptive preset to compute the output pixel rate). Still returns on the header without decoding the stream.
+- **Fix**: Transcode no longer thrashes between positions. `#ensureEncodingFor` now anchors the look-ahead window on the **current** encode position (not the run's start), and a `RESTART_COOLDOWN_MS` guard ignores competing seek-restart requests for a few seconds. Previously a stalled player requesting distant segments (e.g. #2 and #107) made ffmpeg ping-pong, restarting endlessly and producing nothing — which `Error opening input file` races confirmed.
+
+## 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.

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.6",
+  "version": "2.9.9",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/server.js

@@ -27,7 +27,7 @@ import { createSourceRegistry } from "./store/source-registry.js";
 import { TorrentPool } from "./services/torrent-pool.js";
 import { HlsSessionManager } from "./services/hls-session-manager.js";
 import { createPlaybackPlanner } from "./services/playback-planner.js";
-import { detectVideoEncoder } from "./services/hwaccel.js";
+import { detectVideoEncoder, benchmarkSoftwarePresets } from "./services/hwaccel.js";
 import { logger } from "./utils/logger.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -99,12 +99,19 @@ export async function startProxyServer({ host, port, transcodeAudio, ffmpegBin }
   const videoEncoder = transcodeAudio
     ? await detectVideoEncoder({ ffmpegBin, logger })
     : null;
+  // For software libx264, benchmark preset throughput once at startup so the
+  // session manager can pick the highest-quality preset that still encodes each
+  // stream faster than realtime. Hardware encoders use their own fixed preset.
+  const softwarePresetBenchmark = videoEncoder?.kind === "software"
+    ? await benchmarkSoftwarePresets({ ffmpegBin, logger })
+    : null;
   const hlsSessionManager = new HlsSessionManager({
     enabled: transcodeAudio,
     ffmpegBin,
     localBindHost: host,
     localPort: selectedPort,
-    videoEncoder
+    videoEncoder,
+    softwarePresetBenchmark
   });
   const playbackPlanner = createPlaybackPlanner({
     ffmpegBin,

package/services/hls-session-manager.js

@@ -15,7 +15,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { logger } from "../utils/logger.js";
-import { softwareDescriptor } from "./hwaccel.js";
+import { softwareDescriptor, pickSoftwarePreset, TRANSCODE_FPS } from "./hwaccel.js";
 
 const PLAYLIST_FILE_NAME = "index.m3u8";
 const SEGMENT_FILE_NAME_PATTERN = /^segment-\d{5}\.ts$/;
@@ -25,6 +25,11 @@ const DEFAULT_SEGMENT_DURATION_SEC = 4;
 // is allowed to be before we restart ffmpeg at that position (server-side seek).
 // Requests within the window are served by waiting for the running encode.
 const MAX_LOOKAHEAD_SEGMENTS = 8;
+// After a seek-restart, ignore competing restart requests for this long. The
+// synthetic VOD playlist lets the player request distant segments in quick
+// succession (stall-recovery seeks); without a cooldown ffmpeg ping-pongs
+// between positions, restarting endlessly and producing nothing.
+const RESTART_COOLDOWN_MS = 4_000;
 // Idle TTL: a session is disposed this long after the last segment/playlist
 // access. Kept short so an ffmpeg process does not keep burning CPU after the
 // viewer stops or navigates away. Active playback refreshes the timer on every
@@ -247,14 +252,39 @@ function computeProgressMetrics(processedSeconds, totalSeconds, startPositionSec
 }
 
 /**
- * Run a short ffmpeg probe to extract the total duration of a stream.
- * Times out after 8 s and returns `null` on failure.
+ * Parse the source video resolution from ffmpeg's stderr (the "Stream … Video:
+ * … WxH" line). Returns `{ width: null, height: null }` when absent.
+ *
+ * @param {string} stderrText
+ * @returns {{ width: number | null, height: number | null }}
+ */
+function parseFfmpegVideoDimensions(stderrText) {
+  if (typeof stderrText !== "string" || stderrText.length === 0) {
+    return { width: null, height: null };
+  }
+  const match = stderrText.match(/Video:[^\n]*?\b(\d{2,5})x(\d{2,5})\b/i);
+  if (!match) {
+    return { width: null, height: null };
+  }
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  return {
+    width: Number.isFinite(width) && width > 0 ? width : null,
+    height: Number.isFinite(height) && height > 0 ? height : null
+  };
+}
+
+/**
+ * Run a short ffmpeg probe to extract the total duration AND video resolution
+ * of a stream from the container header. Both are printed almost immediately
+ * (before any decoding), so this returns as soon as they are seen; an 8 s
+ * timeout guards the rest.
  *
  * @param {string} ffmpegBin - Path to the ffmpeg executable.
  * @param {string | URL} inputUrl - URL of the stream to probe.
- * @returns {Promise<number | null>} Duration in seconds, or `null`.
+ * @returns {Promise<{ durationSeconds: number | null, width: number | null, height: number | null }>}
  */
-async function probeInputDurationSeconds(ffmpegBin, inputUrl) {
+async function probeInputMediaInfo(ffmpegBin, inputUrl) {
   return new Promise((resolve) => {
     const ffmpeg = spawn(ffmpegBin, ["-hide_banner", "-loglevel", "info", "-i", inputUrl, "-f", "null", "-"], {
       stdio: ["ignore", "ignore", "pipe"],
@@ -262,44 +292,74 @@ async function probeInputDurationSeconds(ffmpegBin, inputUrl) {
     });
     let stderr = "";
     let settled = false;
-    const finish = (value) => {
+    const finish = () => {
       if (settled) {
         return;
       }
       settled = true;
-      resolve(value);
+      const dims = parseFfmpegVideoDimensions(stderr);
+      resolve({ durationSeconds: parseFfmpegDurationSeconds(stderr), width: dims.width, height: dims.height });
     };
     const timeoutId = setTimeout(() => {
       if (!ffmpeg.killed) {
         ffmpeg.kill("SIGTERM");
       }
-      finish(parseFfmpegDurationSeconds(stderr));
+      finish();
     }, 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.
+      // The header ("Duration:" then the "Video: … WxH" stream line) is printed
+      // before any decoding. Bail as soon as both are present instead of letting
+      // `-f null -` decode the whole stream until the 8 s timeout.
       const duration = parseFfmpegDurationSeconds(stderr);
-      if (duration != null) {
+      const dims = parseFfmpegVideoDimensions(stderr);
+      if (duration != null && dims.width != null) {
         clearTimeout(timeoutId);
         if (!ffmpeg.killed) {
           ffmpeg.kill("SIGTERM");
         }
-        finish(duration);
+        finish();
       }
     });
     ffmpeg.on("error", () => {
       clearTimeout(timeoutId);
-      finish(null);
+      finish();
     });
     ffmpeg.on("exit", () => {
       clearTimeout(timeoutId);
-      finish(parseFfmpegDurationSeconds(stderr));
+      finish();
     });
   });
 }
 
+/**
+ * Compute the actual output resolution ffmpeg will produce: the target box
+ * capped to the source (never upscaled), preserving aspect, divisible by 2.
+ * Mirrors the `scale='min(w,iw)':'min(h,ih)':force_original_aspect_ratio=decrease`
+ * filter. Returns `null` when the source size is unknown.
+ *
+ * @param {number} targetWidth
+ * @param {number} targetHeight
+ * @param {number | null} sourceWidth
+ * @param {number | null} sourceHeight
+ * @returns {{ w: number, h: number } | null}
+ */
+function computeOutputDimensions(targetWidth, targetHeight, sourceWidth, sourceHeight) {
+  const sw = Number.isFinite(sourceWidth) && sourceWidth > 0 ? sourceWidth : 0;
+  const sh = Number.isFinite(sourceHeight) && sourceHeight > 0 ? sourceHeight : 0;
+  if (!sw || !sh) {
+    return null;
+  }
+  const tw = Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : sw;
+  const th = Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : sh;
+  const scale = Math.min(tw / sw, th / sh, 1);
+  let w = Math.round(sw * scale);
+  let h = Math.round(sh * scale);
+  w -= w % 2;
+  h -= h % 2;
+  return { w: Math.max(2, w), h: Math.max(2, h) };
+}
+
 function isWarmupTimeoutError(error) {
   if (!(error instanceof Error)) {
     return false;
@@ -364,7 +424,8 @@ export class HlsSessionManager {
     segmentDurationSec = DEFAULT_SEGMENT_DURATION_SEC,
     sessionTtlMs = DEFAULT_SESSION_TTL_MS,
     startupWaitMs = DEFAULT_STARTUP_WAIT_MS,
-    videoEncoder = null
+    videoEncoder = null,
+    softwarePresetBenchmark = null
   }) {
     this.enabled = Boolean(enabled);
     this.ffmpegBin = ffmpegBin;
@@ -372,6 +433,10 @@ export class HlsSessionManager {
     // software libx264 when no detection result is supplied. May be downgraded
     // to software at runtime if a hardware encode fails.
     this.videoEncoder = videoEncoder ?? softwareDescriptor();
+    // Per-preset software encode throughput (pixels/sec) measured at startup,
+    // used to pick the best preset per stream. Null when unavailable (hardware
+    // encoder, or benchmark skipped/failed).
+    this.softwarePresetBenchmark = Array.isArray(softwarePresetBenchmark) ? softwarePresetBenchmark : null;
     this.segmentDurationSec = segmentDurationSec;
     this.sessionTtlMs = sessionTtlMs;
     this.startupWaitMs = startupWaitMs;
@@ -469,7 +534,10 @@ export class HlsSessionManager {
     // playlist (terminated with #EXT-X-ENDLIST) immediately.  This gives the
     // player the correct total duration and a fully seekable timeline before a
     // single segment has been transcoded.
-    const durationSeconds = await probeInputDurationSeconds(this.ffmpegBin, inputUrl.toString());
+    const mediaInfo = await probeInputMediaInfo(this.ffmpegBin, inputUrl.toString());
+    const durationSeconds = mediaInfo.durationSeconds;
+    const sourceWidth = mediaInfo.width;
+    const sourceHeight = mediaInfo.height;
     const hasDuration = Number.isFinite(durationSeconds) && durationSeconds > 0;
     const logName = normalizeLogFileName(fileName, fileIndex);
     if (!hasDuration) {
@@ -482,6 +550,18 @@ export class HlsSessionManager {
       ? Math.max(1, Math.ceil(durationSeconds / this.segmentDurationSec))
       : 0;
 
+    // Pick the highest-quality software preset that still encodes the actual
+    // (source-capped) output resolution faster than realtime. Null for hardware
+    // encoders or when the source size / benchmark is unavailable — buildVideoArgs
+    // then uses its static default preset.
+    const softwarePreset = this.#chooseSoftwarePreset({
+      transcodeVideo,
+      targetWidth: normalizedTargetWidth,
+      targetHeight: normalizedTargetHeight,
+      sourceWidth,
+      sourceHeight
+    });
+
     const session = {
       id: sessionId,
       sourceMapKey,
@@ -501,6 +581,10 @@ export class HlsSessionManager {
       transcodeAudio,
       targetWidth: normalizedTargetWidth,
       targetHeight: normalizedTargetHeight,
+      sourceWidth,
+      sourceHeight,
+      // Chosen libx264 preset for this stream (software only), or null.
+      softwarePreset,
       inputUrl: inputUrl.toString(),
       // VOD playlist bookkeeping.
       useSyntheticPlaylist: hasDuration,
@@ -511,6 +595,8 @@ export class HlsSessionManager {
       encodeStartIndex: 0,
       // Guards against repeatedly restarting to the same seek position.
       pendingRestartIndex: -1,
+      // Timestamp of the last encode (re)start, for the restart cooldown.
+      lastRestartAt: 0,
       progress: {
         state: "starting",
         processedSeconds: 0,
@@ -528,7 +614,9 @@ export class HlsSessionManager {
 
     logger.info(
       `transcode ${sessionId} start "${logName}" ` +
-        `video=${transcodeVideo ? this.videoEncoder.name : "copy"} audio=${transcodeAudio ? "aac" : "copy"} ` +
+        `video=${transcodeVideo ? `${this.videoEncoder.name}${softwarePreset ? `/${softwarePreset}` : ""}` : "copy"} ` +
+        `audio=${transcodeAudio ? "aac" : "copy"} ` +
+        `${sourceWidth && sourceHeight ? `src=${sourceWidth}x${sourceHeight} ` : ""}` +
         `duration=${hasDuration ? formatSeconds(durationSeconds) : "unknown"} segments=${segmentCount}`
     );
 
@@ -580,6 +668,28 @@ export class HlsSessionManager {
     return `${lines.join("\n")}\n`;
   }
 
+  /**
+   * Choose the libx264 preset for a software video transcode: the highest
+   * quality the startup benchmark says this host can encode at the actual
+   * (source-capped) output resolution faster than realtime. Returns null when
+   * not applicable (no video transcode, hardware encoder, or missing
+   * benchmark/source size) — buildVideoArgs then uses its default preset.
+   *
+   * @param {{ transcodeVideo: boolean, targetWidth: number, targetHeight: number, sourceWidth: number | null, sourceHeight: number | null }} params
+   * @returns {string | null}
+   */
+  #chooseSoftwarePreset({ transcodeVideo, targetWidth, targetHeight, sourceWidth, sourceHeight }) {
+    if (!transcodeVideo || this.videoEncoder?.kind !== "software" || !this.softwarePresetBenchmark) {
+      return null;
+    }
+    const out = computeOutputDimensions(targetWidth, targetHeight, sourceWidth, sourceHeight);
+    if (!out) {
+      return null;
+    }
+    const pixelsPerSecNeeded = out.w * out.h * TRANSCODE_FPS;
+    return pickSoftwarePreset(this.softwarePresetBenchmark, pixelsPerSecNeeded);
+  }
+
   /**
    * (Re)start the ffmpeg encode run beginning at segment `startIndex`.
    *
@@ -614,7 +724,9 @@ export class HlsSessionManager {
       ? this.videoEncoder.buildVideoArgs({
           targetWidth: session.targetWidth,
           targetHeight: session.targetHeight,
-          segmentDurationSec: this.segmentDurationSec
+          segmentDurationSec: this.segmentDurationSec,
+          // Software-only; hardware descriptors ignore it.
+          preset: session.softwarePreset ?? undefined
         })
       : ["-c:v", "copy"];
     const audioCodecArgs = session.transcodeAudio
@@ -668,6 +780,7 @@ export class HlsSessionManager {
     session.ffmpeg = ffmpeg;
     session.encodeStartIndex = safeIndex;
     session.pendingRestartIndex = -1;
+    session.lastRestartAt = Date.now();
     session.state = session.state === "disposed" ? "disposed" : "starting";
     session.progress.state = "running";
     session.progress.processedSeconds = startSeconds;
@@ -815,15 +928,32 @@ export class HlsSessionManager {
       return;
     }
     const head = session.encodeStartIndex;
-    const withinWindow = index >= head && index <= head + MAX_LOOKAHEAD_SEGMENTS;
+    // Anchor the look-ahead window on the CURRENT encode position (start index +
+    // seconds already processed), not the run's start index. Otherwise a long
+    // run that has encoded well past `head` would needlessly restart for a
+    // request just ahead of the live edge.
+    const processed = Number.isFinite(session.progress?.processedSeconds)
+      ? session.progress.processedSeconds
+      : head * this.segmentDurationSec;
+    const currentSeg = Math.max(head, Math.floor(processed / this.segmentDurationSec));
+    const withinWindow = index >= head && index <= currentSeg + MAX_LOOKAHEAD_SEGMENTS;
     if (withinWindow) {
       return;
     }
     if (session.pendingRestartIndex === index) {
       return;
     }
+    // Restart cooldown: a stalled player requests several distant segments in
+    // quick succession; without this guard ffmpeg ping-pongs between them and
+    // never makes progress. Skip the restart during the cooldown — the caller
+    // long-polls / the client retries, and a genuine seek is honored once the
+    // cooldown elapses.
+    const sinceLastRestart = Date.now() - (session.lastRestartAt ?? 0);
+    if (sinceLastRestart < RESTART_COOLDOWN_MS) {
+      return;
+    }
     logger.info(
-      `transcode ${session.id} seek → restart at segment #${index} (encode head #${head})`
+      `transcode ${session.id} seek → restart at segment #${index} (encode head #${head}, current #${currentSeg})`
     );
     this.#startEncodeRun(session, index);
   }

package/services/hwaccel.js

@@ -25,9 +25,20 @@ import { mkdtempSync, readdirSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-const SOFTWARE_PRESET = "superfast";
+const SOFTWARE_PRESET = "ultrafast";
 const SOFTWARE_CRF = "24";
-const TRANSCODE_FPS = 24;
+export const TRANSCODE_FPS = 24;
+// Software x264 on weak ARM hosts is the transcode bottleneck — use all cores.
+const CPU_THREADS = Math.max(1, os.cpus().length);
+
+// libx264 presets to benchmark, ordered slowest/highest-quality → fastest.
+const BENCHMARK_PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
+const BENCHMARK_REF_W = 640;
+const BENCHMARK_REF_H = 360;
+const BENCHMARK_DURATION_SEC = 3;
+// Require the encoder to be this much faster than realtime for the target
+// resolution, leaving headroom for complex scenes and delivery.
+const PRESET_SPEED_MARGIN = 1.3;
 
 /**
  * @param {number} targetWidth
@@ -58,14 +69,23 @@ export function softwareDescriptor() {
     kind: "software",
     device: null,
     inputArgs: [],
-    buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec }) {
+    buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, preset }) {
       const { w, h } = safeDimensions(targetWidth, targetHeight);
+      const chosenPreset = typeof preset === "string" && preset.length > 0 ? preset : SOFTWARE_PRESET;
       return [
+        // Never upscale: cap the target box to the source size (min with
+        // iw/ih), so a small source (e.g. 720x400) is encoded at its own
+        // resolution instead of being scaled up to the viewport — far fewer
+        // pixels, much faster on ARM. force_original_aspect_ratio keeps aspect.
         "-vf",
-        `scale=${w}:${h}:force_original_aspect_ratio=decrease:force_divisible_by=2,fps=${TRANSCODE_FPS}`,
+        `scale='min(${w},iw)':'min(${h},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2,fps=${TRANSCODE_FPS}`,
         "-c:v", "libx264",
-        "-preset", SOFTWARE_PRESET,
+        // Preset is chosen per stream by the session manager from the startup
+        // benchmark (highest quality that still encodes the source resolution
+        // faster than realtime); falls back to the static default.
+        "-preset", chosenPreset,
         "-crf", SOFTWARE_CRF,
+        "-threads", String(CPU_THREADS),
         "-pix_fmt", "yuv420p",
         ...keyFrameArgs(segmentDurationSec)
       ];
@@ -416,3 +436,66 @@ export async function detectVideoEncoder({ ffmpegBin, logger, segmentDurationSec
   log.info("hwaccel: no working hardware encoder; using software libx264");
   return software;
 }
+
+/**
+ * Benchmark software libx264 presets on this host. Encodes a short synthetic
+ * clip at a fixed reference resolution with each preset and measures encoder
+ * throughput in pixels/second. The session manager uses this to pick, per
+ * stream, the highest-quality preset that still encodes the actual
+ * (source-capped) resolution faster than realtime.
+ *
+ * Runs once at startup; bounded by a per-encode timeout. Presets that fail are
+ * omitted from the result.
+ *
+ * @param {{ ffmpegBin: string, logger?: { info: (m: string) => void, warn: (m: string) => void } }} options
+ * @returns {Promise<Array<{ preset: string, pixelsPerSec: number }>>} Ordered slowest→fastest.
+ */
+export async function benchmarkSoftwarePresets({ ffmpegBin, logger }) {
+  const log = logger ?? { info: () => {}, warn: () => {} };
+  const totalPixels = BENCHMARK_REF_W * BENCHMARK_REF_H * TRANSCODE_FPS * BENCHMARK_DURATION_SEC;
+  /** @type {Array<{ preset: string, pixelsPerSec: number }>} */
+  const results = [];
+  for (const preset of BENCHMARK_PRESETS) {
+    const args = [
+      "-hide_banner", "-loglevel", "error",
+      "-f", "lavfi", "-i", `testsrc2=s=${BENCHMARK_REF_W}x${BENCHMARK_REF_H}:r=${TRANSCODE_FPS}:d=${BENCHMARK_DURATION_SEC}`,
+      "-c:v", "libx264", "-preset", preset, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p",
+      "-f", "null", "-"
+    ];
+    const startedAt = Date.now();
+    const { code } = await runFfmpeg(ffmpegBin, args, 30000);
+    const elapsedSec = (Date.now() - startedAt) / 1000;
+    if (code !== 0 || elapsedSec <= 0) {
+      log.warn(`hwaccel: preset benchmark "${preset}" failed; skipping`);
+      continue;
+    }
+    const pixelsPerSec = totalPixels / elapsedSec;
+    results.push({ preset, pixelsPerSec });
+    log.info(
+      `hwaccel: preset "${preset}" ~= ${(pixelsPerSec / 1e6).toFixed(1)} Mpx/s ` +
+        `(${(BENCHMARK_DURATION_SEC / elapsedSec).toFixed(2)}x @ ${BENCHMARK_REF_W}x${BENCHMARK_REF_H})`
+    );
+  }
+  return results;
+}
+
+/**
+ * Pick the highest-quality (slowest) benchmarked preset that can encode
+ * `pixelsPerSecNeeded` with the speed margin. Falls back to the fastest
+ * benchmarked preset, or `"ultrafast"` when no benchmark is available.
+ *
+ * @param {Array<{ preset: string, pixelsPerSec: number }>} benchmark - slowest→fastest
+ * @param {number} pixelsPerSecNeeded
+ * @returns {string}
+ */
+export function pickSoftwarePreset(benchmark, pixelsPerSecNeeded) {
+  if (!Array.isArray(benchmark) || benchmark.length === 0) {
+    return "ultrafast";
+  }
+  for (const entry of benchmark) {
+    if (entry.pixelsPerSec >= pixelsPerSecNeeded * PRESET_SPEED_MARGIN) {
+      return entry.preset;
+    }
+  }
+  return benchmark[benchmark.length - 1].preset;
+}

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