@torrent-tv/proxy 2.59.1 → 2.59.2

package/package.json

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

package/services/ffmpeg-banner.js

@@ -119,6 +119,54 @@ export function parseFfmpegVideoDimensions(stderrText) {
   };
 }
 
+/**
+ * Count the streams the source declares, by type, from ffmpeg's banner
+ * ("Stream #0:3(rus): Audio: ac3 …").
+ *
+ * Every `-map` this proxy builds carries the `?` suffix, which tells ffmpeg to
+ * drop the mapping silently when the stream is absent instead of refusing. Map
+ * every stream of a run away that way and the output is left with nothing in
+ * it, which ffmpeg reports as `Output file does not contain any stream` and
+ * exit 255 — three sessions died that way on 2026-08-26 and the log held only
+ * the exit code. What separates "we asked for a track that is not there" from
+ * every other cause of 255 is this count, so it is read once, with the rest of
+ * the banner, and kept for the failure to quote.
+ *
+ * @param {string} stderrText
+ * @returns {{ video: number, audio: number, subtitle: number, other: number } | null}
+ *   Null when the banner carried no stream lines at all — which is itself
+ *   different from a file that genuinely has none.
+ */
+export function parseFfmpegStreamCounts(stderrText) {
+  if (typeof stderrText !== "string" || stderrText.length === 0) {
+    return null;
+  }
+  const lines = stderrText.match(/^\s*Stream #\d+:\d+.*$/gim);
+  if (!lines || lines.length === 0) {
+    return null;
+  }
+  const counts = { video: 0, audio: 0, subtitle: 0, other: 0 };
+  for (const line of lines) {
+    // The type follows the stream's id and its optional language/metadata:
+    // "Stream #0:1(eng): Audio: aac". Attached pictures also announce
+    // themselves as Video, and they are counted as such deliberately — that is
+    // exactly what `0:v:0?` would map, and a cover image mapped as the picture
+    // is one of the ways a run ends up producing nothing anyone can watch.
+    const match = line.match(/Stream #\d+:\d+(?:\[[^\]]*\])?(?:\([^)]*\))?:\s*(\w+)/i);
+    const kind = match ? match[1].toLowerCase() : "";
+    if (kind === "video") {
+      counts.video += 1;
+    } else if (kind === "audio") {
+      counts.audio += 1;
+    } else if (kind === "subtitle") {
+      counts.subtitle += 1;
+    } else {
+      counts.other += 1;
+    }
+  }
+  return counts;
+}
+
 /**
  * Parse the source frame rate from the ffmpeg "Video:" line
  * (e.g. "… 23.98 fps," / "… 25 fps,"). Returns null when absent.

package/services/hls-session-manager.js

@@ -53,6 +53,7 @@ import {
   parseFfmpegBitrateKbps,
   parseFfmpegDurationSeconds,
   parseFfmpegStartTimeSeconds,
+  parseFfmpegStreamCounts,
   parseFfmpegVideoDimensions,
   parseFfmpegVideoFps,
   parseFfmpegHdr
@@ -854,6 +855,10 @@ async function probeInputMediaInfo(ffmpegBin, inputUrl) {
         height: dims.height,
         fps: parseFfmpegVideoFps(stderr),
         startTime: parseFfmpegStartTimeSeconds(stderr),
+        // Only ever read when a run fails, and read HERE because by then the
+        // banner is long gone: this probe is the one place the source says what
+        // it holds.
+        streamCounts: parseFfmpegStreamCounts(stderr),
         isHdr: parseFfmpegHdr(stderr)
       });
     };
@@ -2109,6 +2114,10 @@ export class HlsSessionManager {
       audioOnly: audioOnly === true,
       audioRenditions: audioRenditions === true,
       outputFps,
+      // What the source declared it holds, kept for a failed run to quote. Null
+      // when the media info came from a cache that predates this field or from
+      // a probe whose banner carried no stream lines.
+      sourceStreamCounts: mediaInfo.streamCounts ?? null,
       // Client-requested target box (the orientation-independent ceiling). Kept
       // for the session key and reference; the actual encode uses encodeWidth/
       // encodeHeight, which the realtime budget may have downscaled below this.
@@ -4806,7 +4815,12 @@ export class HlsSessionManager {
     session.runCounter = (session.runCounter ?? 0) + 1;
     const runLabel = `run#${session.runCounter}`;
     session.runLabel = runLabel;
-    logger.info(`transcode ${session.id} ${runLabel} ffmpeg ${describeFfmpegArgs(args)}`);
+    const describedArgs = describeFfmpegArgs(args);
+    // Kept so a failure can quote the command that produced it instead of
+    // leaving whoever reads the log to find it among the lines of the runs that
+    // succeeded around it.
+    session.lastRunArgsDescribed = describedArgs;
+    logger.info(`transcode ${session.id} ${runLabel} ffmpeg ${describedArgs}`);
 
     const ffmpeg = spawn(this.ffmpegBin, args, {
       cwd: session.runDirPath ?? session.dirPath,
@@ -5108,11 +5122,46 @@ export class HlsSessionManager {
       session.progress.updatedAt = Date.now();
       this.#transitionRun(session, ENCODE_RUN_EVENT.EXITED_FAILED);
       logger.error(
-        `transcode ${session.id} ${session.runLabel ?? "run#?"} encode-run failed: ${session.lastError}`
+        `transcode ${session.id} ${session.runLabel ?? "run#?"} encode-run failed: ${session.lastError}` +
+          ` — ${this.#describeTrackSelection(session)}` +
+          `\n  ffmpeg ${session.lastRunArgsDescribed ?? "(command not recorded)"}`
       );
     });
   }
 
+  /**
+   * What this run asked the source for, against what the source said it has.
+   *
+   * Written for one failure in particular: every `-map` this proxy builds ends
+   * in `?`, so ffmpeg drops a mapping for an absent stream without complaint,
+   * and a run whose mappings ALL drop produces a file with nothing in it —
+   * reported as `Output file does not contain any stream`, exit 255. Read from
+   * the exit code alone that is indistinguishable from any other refusal. Read
+   * beside the tracks the file actually holds it is unmistakable, and it names
+   * which side is wrong: an audio index past the end of the list is ours, no
+   * streams at all is the source's.
+   *
+   * @param {HlsSession} session
+   * @returns {string}
+   */
+  #describeTrackSelection(session) {
+    const wanted = [];
+    if (session.audioOnly === true) {
+      wanted.push(`audio 0:a:${session.audioTrackIndex ?? 0}`);
+    } else if (this.#servesAudioSeparately(session)) {
+      wanted.push("video 0:v:0");
+    } else {
+      wanted.push("video 0:v:0", `audio 0:a:${session.audioTrackIndex ?? 0}`);
+    }
+    const counts = session.sourceStreamCounts;
+    const held = counts
+      ? `the source holds ${counts.video} video, ${counts.audio} audio, ` +
+        `${counts.subtitle} subtitle` +
+        (counts.other > 0 ? `, ${counts.other} other` : "")
+      : "what the source holds was not recorded";
+    return `this run asked for ${wanted.join(" + ")}, and ${held}`;
+  }
+
   /**
    * Ensure the encoder is producing (or will soon produce) the requested
    * segment.  If the segment is far ahead of the current encode head, or

package/test/ffmpeg-stream-counts.test.js

@@ -0,0 +1,78 @@
+/**
+ * @file What the source said it holds, read from ffmpeg's own banner.
+ *
+ * The reading exists for one failure: every `-map` this proxy builds ends in
+ * `?`, so ffmpeg drops a mapping for a stream that is not there and says
+ * nothing. Map every stream of a run away that way and the output has nothing
+ * in it — `Output file does not contain any stream`, exit 255. Three sessions
+ * died that way on 2026-08-26 and the log held only the code.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseFfmpegStreamCounts } from "../services/ffmpeg-banner.js";
+
+const FIELD_BANNER = `
+Input #0, matroska,webm, from 'http://127.0.0.1:9090/stream?sourceKey=b3f08efc':
+  Duration: 01:32:39.00, start: 0.000000, bitrate: 9354 kb/s
+  Stream #0:0: Video: h264 (High), yuv420p(progressive), 1920x1080, 23.98 fps
+  Stream #0:1(rus): Audio: ac3, 48000 Hz, 5.1, fltp, 640 kb/s
+  Stream #0:2(eng): Audio: aac, 48000 Hz, stereo, fltp, 128 kb/s
+  Stream #0:3(rus): Subtitle: subrip
+  Stream #0:4(eng): Subtitle: hdmv_pgs_subtitle
+`;
+
+test("each stream is counted under the type ffmpeg names it", () => {
+  assert.deepEqual(parseFfmpegStreamCounts(FIELD_BANNER), {
+    video: 1,
+    audio: 2,
+    subtitle: 2,
+    other: 0
+  });
+});
+
+test("a file with no audio is what makes an audio-only run produce nothing", () => {
+  // This is the shape the diagnostic is for: the rendition asks for `0:a:0?`,
+  // the file has no audio at all, the mapping is dropped in silence and the
+  // segment muxer is handed an output with no streams.
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0: Video: hevc (Main 10), yuv420p10le, 3840x2160, 23.98 fps
+  `);
+  assert.equal(counts.audio, 0);
+  assert.equal(counts.video, 1);
+});
+
+test("an audio index past the end of the list is OUR fault, and the counts say so", () => {
+  // A viewer picking the third dub on a file carrying one: `0:a:2?` drops, and
+  // the count is what separates that from a source that delivered nothing.
+  const counts = parseFfmpegStreamCounts(FIELD_BANNER);
+  const askedFor = 4;
+  assert.ok(askedFor >= counts.audio, "the request is outside what the file holds");
+});
+
+test("an attached cover image is counted as video, because that is what would be mapped", () => {
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 320 kb/s
+  Stream #0:1: Video: mjpeg (Baseline), yuvj420p(pc), 600x600 (attached pic)
+  `);
+  assert.equal(counts.video, 1);
+  assert.equal(counts.audio, 1);
+});
+
+test("a banner carrying no stream lines is not the same as a file with no streams", () => {
+  // Null says "not recorded"; zeroes would claim a measurement nobody took.
+  assert.equal(parseFfmpegStreamCounts("Duration: 00:10:00.00, start: 0.000000"), null);
+  assert.equal(parseFfmpegStreamCounts(""), null);
+  assert.equal(parseFfmpegStreamCounts(undefined), null);
+});
+
+test("a stream carrying metadata in brackets is still read", () => {
+  // MP4 writes `Stream #0:1[0x2](eng)`, which the earlier shape of this regex
+  // would have skipped.
+  const counts = parseFfmpegStreamCounts(`
+  Stream #0:0[0x1](und): Video: h264 (avc1), yuv420p, 1280x720, 24 fps
+  Stream #0:1[0x2](eng): Audio: aac (mp4a), 48000 Hz, stereo, fltp
+  `);
+  assert.deepEqual(counts, { video: 1, audio: 1, subtitle: 0, other: 0 });
+});