@torrent-tv/proxy 2.89.7 → 2.89.8

package/services/encode/SoftwareEncoder.js

@@ -1,121 +1,121 @@
-/**
- * @file libx264 — the encoder every host has and the only one whose ladder of
- * speed settings is measured at startup.
- */
-
-import { Encoder } from "./Encoder.js";
-import {
-  CPU_THREADS,
-  hasForcedTimes,
-  keyFrameArgs,
-  rateControlArgs,
-  safeDimensions,
-  SOFTWARE_CRF,
-  SOFTWARE_PRESET,
-  TONEMAP_FILTER_CHAIN,
-  TRANSCODE_FPS
-} from "./args.js";
-
-/**
- * The presets the startup benchmark walks, slowest first.
- *
- * The same list `benchmarkSoftwarePresets` measures and `pickSoftwarePreset`
- * chooses from; it is stated here because it is a property of this kind, and
- * the four hardware kinds beside it show what its absence looks like.
- */
-const PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
-
-export class SoftwareEncoder extends Encoder {
-  constructor() {
-    super({ name: "libx264", kind: "software", device: null, inputArgs: [] });
-  }
-
-  /** @returns {import("./Encoder.js").SpeedLadder} */
-  get speedLadder() {
-    return {
-      flag: "-preset",
-      values: PRESETS,
-      measured: true,
-      note:
-        "Measured on every host at startup by `benchmarkSoftwarePresets`, in " +
-        "pixels per second per preset, and chosen from by `pickSoftwarePreset`."
-    };
-  }
-
-  /** Every preset: `buildVideoArgs` passes whichever the offer chose. */
-  get selectableRungs() {
-    return PRESETS;
-  }
-
-  /** @param {string | null} rung @returns {string[]} */
-  benchmarkArgs(rung = null) {
-    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
-  }
-
-  buildVideoArgs({
-    targetWidth,
-    targetHeight,
-    segmentDurationSec,
-    preset,
-    fps,
-    tonemap,
-    forcedKeyframeTimes,
-    rateControl = null
-  }) {
-    const { w, h } = safeDimensions(targetWidth, targetHeight);
-    const chosenPreset = typeof preset === "string" && preset.length > 0 ? preset : SOFTWARE_PRESET;
-    // Output frame rate: inherited from the source (rounded/capped) by the
-    // session manager, TRANSCODE_FPS by default. MUST be an integer and MUST
-    // equal the value used in the GOP below, or keyframes drift off the grid.
-    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
-    // HDR→SDR tone-map, inserted AFTER the downscale so it runs on the smaller
-    // frame (cheaper on ARM); only when the source is HDR and the filters are
-    // present (session manager gates on both).
-    const tonemapPart = tonemap === true ? `,${TONEMAP_FILTER_CHAIN}` : "";
-    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='min(${w},iw)':'min(${h},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2${tonemapPart},fps=${outFps}`,
-      "-c:v", "libx264",
-      // 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,
-      // Constrained CRF: bound peak bitrate so a complex scene cannot produce
-      // segments a thin viewer link (cellular) can't download in time. The
-      // figures and the level are the OUTPUT's own, named by its key
-      // (`OutputSpec`), and are not worked out again here.
-      ...rateControlArgs(rateControl),
-      "-threads", String(CPU_THREADS),
-      "-pix_fmt", "yuv420p",
-      // Fixed GOP: a keyframe exactly every (segmentDurationSec × fps) frames,
-      // scene-cut keyframes disabled. This is frame-count based, so it is
-      // independent of the PTS offset used on seek-restart — every HLS segment
-      // is exactly segmentDurationSec long and starts on a keyframe, so segment
-      // boundaries line up with the synthetic playlist with no gaps. (The old
-      // the OLD `expr:` form of -force_key_frames broke after a seek, because
-      // the `t` it reads is shifted by `-output_ts_offset`.)
-      //
-      // An explicit cut LIST is a different thing and does work: verified by
-      // running it, its times are on the run's own timeline — the same one
-      // `-segment_times` is measured on — so both are given one list and
-      // cannot drift apart. It replaces the frame-count GOP, which cannot
-      // describe the source's keyframes because they are not evenly spaced.
-      // `-g` stays as an upper bound on the interval: an extra keyframe
-      // inside a segment costs a little bitrate and cuts nothing, while
-      // leaving the interval unbounded means a driver that ignores the list
-      // produces one enormous segment instead of a wrong but cut one.
-      // `-keyint_min` goes, since a MINIMUM interval is the one thing that
-      // could argue with a forced keyframe.
-      "-g", String(segmentDurationSec * outFps),
-      ...(hasForcedTimes(forcedKeyframeTimes)
-        ? keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
-        : ["-keyint_min", String(segmentDurationSec * outFps)]),
-      "-sc_threshold", "0"
-    ];
-  }
-}
+/**
+ * @file libx264 — the encoder every host has and the only one whose ladder of
+ * speed settings is measured at startup.
+ */
+
+import { Encoder } from "./Encoder.js";
+import {
+  CPU_THREADS,
+  hasForcedTimes,
+  keyFrameArgs,
+  rateControlArgs,
+  safeDimensions,
+  SOFTWARE_CRF,
+  SOFTWARE_PRESET,
+  TONEMAP_FILTER_CHAIN,
+  TRANSCODE_FPS
+} from "./args.js";
+
+/**
+ * The presets the startup benchmark walks, slowest first.
+ *
+ * The same list `benchmarkSoftwarePresets` measures and `pickSoftwarePreset`
+ * chooses from; it is stated here because it is a property of this kind, and
+ * the four hardware kinds beside it show what its absence looks like.
+ */
+const PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
+
+export class SoftwareEncoder extends Encoder {
+  constructor() {
+    super({ name: "libx264", kind: "software", device: null, inputArgs: [] });
+  }
+
+  /** @returns {import("./Encoder.js").SpeedLadder} */
+  get speedLadder() {
+    return {
+      flag: "-preset",
+      values: PRESETS,
+      measured: true,
+      note:
+        "Measured on every host at startup by `benchmarkSoftwarePresets`, in " +
+        "pixels per second per preset, and chosen from by `pickSoftwarePreset`."
+    };
+  }
+
+  /** Every preset: `buildVideoArgs` passes whichever the offer chose. */
+  get selectableRungs() {
+    return PRESETS;
+  }
+
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
+  }
+
+  buildVideoArgs({
+    targetWidth,
+    targetHeight,
+    segmentDurationSec,
+    preset,
+    fps,
+    tonemap,
+    forcedKeyframeTimes,
+    rateControl = null
+  }) {
+    const { w, h } = safeDimensions(targetWidth, targetHeight);
+    const chosenPreset = typeof preset === "string" && preset.length > 0 ? preset : SOFTWARE_PRESET;
+    // Output frame rate: inherited from the source (rounded/capped) by the
+    // session manager, TRANSCODE_FPS by default. MUST be an integer and MUST
+    // equal the value used in the GOP below, or keyframes drift off the grid.
+    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
+    // HDR→SDR tone-map, inserted AFTER the downscale so it runs on the smaller
+    // frame (cheaper on ARM); only when the source is HDR and the filters are
+    // present (session manager gates on both).
+    const tonemapPart = tonemap === true ? `,${TONEMAP_FILTER_CHAIN}` : "";
+    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='min(${w},iw)':'min(${h},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2${tonemapPart},fps=${outFps}`,
+      "-c:v", "libx264",
+      // 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,
+      // Constrained CRF: bound peak bitrate so a complex scene cannot produce
+      // segments a thin viewer link (cellular) can't download in time. The
+      // figures and the level are the OUTPUT's own, named by its key
+      // (`OutputSpec`), and are not worked out again here.
+      ...rateControlArgs(rateControl),
+      "-threads", String(CPU_THREADS),
+      "-pix_fmt", "yuv420p",
+      // Fixed GOP: a keyframe exactly every (segmentDurationSec × fps) frames,
+      // scene-cut keyframes disabled. This is frame-count based, so it is
+      // independent of the PTS offset used on seek-restart — every HLS segment
+      // is exactly segmentDurationSec long and starts on a keyframe, so segment
+      // boundaries line up with the synthetic playlist with no gaps. (The old
+      // the OLD `expr:` form of -force_key_frames broke after a seek, because
+      // the `t` it reads is shifted by `-output_ts_offset`.)
+      //
+      // An explicit cut LIST is a different thing and does work: verified by
+      // running it, its times are on the run's own timeline — the same one
+      // `-segment_times` is measured on — so both are given one list and
+      // cannot drift apart. It replaces the frame-count GOP, which cannot
+      // describe the source's keyframes because they are not evenly spaced.
+      // `-g` stays as an upper bound on the interval: an extra keyframe
+      // inside a segment costs a little bitrate and cuts nothing, while
+      // leaving the interval unbounded means a driver that ignores the list
+      // produces one enormous segment instead of a wrong but cut one.
+      // `-keyint_min` goes, since a MINIMUM interval is the one thing that
+      // could argue with a forced keyframe.
+      "-g", String(segmentDurationSec * outFps),
+      ...(hasForcedTimes(forcedKeyframeTimes)
+        ? keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
+        : ["-keyint_min", String(segmentDurationSec * outFps)]),
+      "-sc_threshold", "0"
+    ];
+  }
+}

package/services/encode/V4l2m2mEncoder.js

@@ -1,53 +1,53 @@
-/**
- * @file h264_v4l2m2m — the stateful memory-to-memory encoder on an ARM board
- * (Raspberry Pi, HA Yellow).
- */
-
-import { Encoder } from "./Encoder.js";
-import { keyFrameArgs, safeDimensions, TRANSCODE_FPS } from "./args.js";
-
-export class V4l2m2mEncoder extends Encoder {
-  constructor() {
-    // ARM SoC (e.g. Raspberry Pi / HA Yellow) stateful M2M encoder. No GPU
-    // scaler — scale in software, hand YUV420 frames to the hardware encoder.
-    super({ name: "h264_v4l2m2m", kind: "v4l2m2m", device: null, inputArgs: [] });
-  }
-
-  /** @returns {import("./Encoder.js").SpeedLadder} */
-  get speedLadder() {
-    return {
-      flag: "",
-      values: [],
-      measured: false,
-      note:
-        "This kind has no speed setting at all — its levers are the bitrate " +
-        "and the number of capture buffers, which are not a trade of picture " +
-        "against speed. So there is nowhere to step, and a host that cannot " +
-        "keep up on it has to change something else."
-    };
-  }
-
-  // `-g` aligns the GOP to the segment length so an IDR lands on every segment
-  // boundary; this is verified by the keyframe-alignment test before use,
-  // because v4l2m2m does not always honour these hints.
-  buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, fps, forcedKeyframeTimes }) {
-    const { w, h } = safeDimensions(targetWidth, targetHeight);
-    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
-    return [
-      "-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",
-      // Kept even with an explicit cut list, as an upper bound on the
-      // interval: this encoder is the one known not always to honour keyframe
-      // hints, and without any bound a list it ignores yields one segment for
-      // the whole file rather than a wrongly-cut one.
-      "-g", String(outFps * segmentDurationSec),
-      ...keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
-    ];
-  }
-}
+/**
+ * @file h264_v4l2m2m — the stateful memory-to-memory encoder on an ARM board
+ * (Raspberry Pi, HA Yellow).
+ */
+
+import { Encoder } from "./Encoder.js";
+import { keyFrameArgs, safeDimensions, TRANSCODE_FPS } from "./args.js";
+
+export class V4l2m2mEncoder extends Encoder {
+  constructor() {
+    // ARM SoC (e.g. Raspberry Pi / HA Yellow) stateful M2M encoder. No GPU
+    // scaler — scale in software, hand YUV420 frames to the hardware encoder.
+    super({ name: "h264_v4l2m2m", kind: "v4l2m2m", device: null, inputArgs: [] });
+  }
+
+  /** @returns {import("./Encoder.js").SpeedLadder} */
+  get speedLadder() {
+    return {
+      flag: "",
+      values: [],
+      measured: false,
+      note:
+        "This kind has no speed setting at all — its levers are the bitrate " +
+        "and the number of capture buffers, which are not a trade of picture " +
+        "against speed. So there is nowhere to step, and a host that cannot " +
+        "keep up on it has to change something else."
+    };
+  }
+
+  // `-g` aligns the GOP to the segment length so an IDR lands on every segment
+  // boundary; this is verified by the keyframe-alignment test before use,
+  // because v4l2m2m does not always honour these hints.
+  buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, fps, forcedKeyframeTimes }) {
+    const { w, h } = safeDimensions(targetWidth, targetHeight);
+    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
+    return [
+      "-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",
+      // Kept even with an explicit cut list, as an upper bound on the
+      // interval: this encoder is the one known not always to honour keyframe
+      // hints, and without any bound a list it ignores yields one segment for
+      // the whole file rather than a wrongly-cut one.
+      "-g", String(outFps * segmentDurationSec),
+      ...keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
+    ];
+  }
+}

package/services/encode/VaapiEncoder.js

@@ -1,66 +1,66 @@
-/**
- * @file h264_vaapi — encode on a VAAPI device, with the scale on the same
- * device so frames never leave it.
- */
-
-import { Encoder } from "./Encoder.js";
-import { keyFrameArgs, safeDimensions } from "./args.js";
-
-export class VaapiEncoder extends Encoder {
-  /**
-   * @param {string} device - Render node, e.g. `/dev/dri/renderD128`.
-   */
-  constructor(device) {
-    super({
-      name: "h264_vaapi",
-      kind: "vaapi",
-      device,
-      // Decode on the GPU into VAAPI surfaces; scale and encode stay on-GPU.
-      inputArgs: ["-hwaccel", "vaapi", "-hwaccel_output_format", "vaapi", "-vaapi_device", device]
-    });
-  }
-
-  /** @returns {import("./Encoder.js").SpeedLadder} */
-  get speedLadder() {
-    return {
-      flag: "-quality",
-      // Read from ffmpeg's own option list on the addon host 2026-09-04:
-      // "Set encode quality (trades off against speed, higher is faster)
-      // (from -1 to INT_MAX) (default -1)". The upper end is the driver's, not
-      // the encoder's, so there is no list to state — only the name of the
-      // setting and the direction.
-      values: [],
-      measured: false,
-      note:
-        "The setting is `-quality`, higher is faster, and its range belongs to " +
-        "the driver rather than to ffmpeg. Nothing here has benchmarked it, " +
-        "and nothing passes it: a VAAPI encode runs at the driver's default."
-    };
-  }
-
-  // No fps filter: VAAPI inherits the source rate and keeps keyframes on the
-  // grid via time-based -force_key_frames, so it already honours source fps.
-  /** @returns {string[]} */
-  benchmarkInputArgs() {
-    return this.device ? ["-vaapi_device", this.device] : [];
-  }
-
-  /** @param {string | null} rung @returns {string[]} */
-  benchmarkArgs(rung = null) {
-    // Raw frames live in this process; VAAPI encodes what is in the device, so
-    // the upload is part of what this kind costs and belongs in the reading.
-    const quality = rung ? ["-quality", rung] : [];
-    return ["-vf", "format=nv12,hwupload", "-c:v", "h264_vaapi", "-qp", "24", ...quality];
-  }
-
-  buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
-    const { w, h } = safeDimensions(targetWidth, targetHeight);
-    return [
-      "-vf",
-      `scale_vaapi=w=${w}:h=${h}:force_original_aspect_ratio=decrease`,
-      "-c:v", "h264_vaapi",
-      "-qp", "24",
-      ...keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
-    ];
-  }
-}
+/**
+ * @file h264_vaapi — encode on a VAAPI device, with the scale on the same
+ * device so frames never leave it.
+ */
+
+import { Encoder } from "./Encoder.js";
+import { keyFrameArgs, safeDimensions } from "./args.js";
+
+export class VaapiEncoder extends Encoder {
+  /**
+   * @param {string} device - Render node, e.g. `/dev/dri/renderD128`.
+   */
+  constructor(device) {
+    super({
+      name: "h264_vaapi",
+      kind: "vaapi",
+      device,
+      // Decode on the GPU into VAAPI surfaces; scale and encode stay on-GPU.
+      inputArgs: ["-hwaccel", "vaapi", "-hwaccel_output_format", "vaapi", "-vaapi_device", device]
+    });
+  }
+
+  /** @returns {import("./Encoder.js").SpeedLadder} */
+  get speedLadder() {
+    return {
+      flag: "-quality",
+      // Read from ffmpeg's own option list on the addon host 2026-09-04:
+      // "Set encode quality (trades off against speed, higher is faster)
+      // (from -1 to INT_MAX) (default -1)". The upper end is the driver's, not
+      // the encoder's, so there is no list to state — only the name of the
+      // setting and the direction.
+      values: [],
+      measured: false,
+      note:
+        "The setting is `-quality`, higher is faster, and its range belongs to " +
+        "the driver rather than to ffmpeg. Nothing here has benchmarked it, " +
+        "and nothing passes it: a VAAPI encode runs at the driver's default."
+    };
+  }
+
+  // No fps filter: VAAPI inherits the source rate and keeps keyframes on the
+  // grid via time-based -force_key_frames, so it already honours source fps.
+  /** @returns {string[]} */
+  benchmarkInputArgs() {
+    return this.device ? ["-vaapi_device", this.device] : [];
+  }
+
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    // Raw frames live in this process; VAAPI encodes what is in the device, so
+    // the upload is part of what this kind costs and belongs in the reading.
+    const quality = rung ? ["-quality", rung] : [];
+    return ["-vf", "format=nv12,hwupload", "-c:v", "h264_vaapi", "-qp", "24", ...quality];
+  }
+
+  buildVideoArgs({ targetWidth, targetHeight, segmentDurationSec, forcedKeyframeTimes }) {
+    const { w, h } = safeDimensions(targetWidth, targetHeight);
+    return [
+      "-vf",
+      `scale_vaapi=w=${w}:h=${h}:force_original_aspect_ratio=decrease`,
+      "-c:v", "h264_vaapi",
+      "-qp", "24",
+      ...keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
+    ];
+  }
+}