@camstack/addon-pipeline 1.1.28 → 1.1.29

package/dist/decoder-ffmpeg/index.mjs

@@ -1,302 +1,10 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, j as nodePin, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-C6_wgXqF.mjs";
-import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, o as DEFAULT_DECODER_BACKEND, t as DecoderFrameRingSink } from "../frame-ring-sink-Cs9vby6v.mjs";
-import { r as logBannerArgs, t as FrameDropper } from "../frame-dropper-CwkBTPGV.mjs";
+import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-DjuGmyG9.mjs";
+import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, o as DEFAULT_DECODER_BACKEND, t as DecoderFrameRingSink } from "../frame-ring-sink-ClEWjiRU.mjs";
+import { a as codecToInputFormat, c as maxDecodeWidth, d as pickDecodeHwAccel, f as rankDecodeHwAccels, i as channelsForPixel, l as parseAvailableGpuScaleFilters, m as resolveGpuScaleFilter, n as DEFAULT_VAAPI_RENDER_DEVICE, o as computeOutputGeometry, p as rawPixelForFormat, r as buildFfmpegDecodeArgs, s as isSoftwareHwAccel, t as DECODE_HWACCEL_RANK, u as parseFfmpegOutputDims } from "../ffmpeg-args-C5GPp8Cw.mjs";
+import { t as FrameDropper } from "../frame-dropper-AjheBGMG.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-//#region src/decoder-ffmpeg/ffmpeg-args.ts
-/**
-* Pure, side-effect-free ffmpeg argument construction for the
-* `decoder-ffmpeg` addon.
-*
-* The addon decodes video in an **ffmpeg subprocess** (unlike `decoder-nodeav`
-* which decodes in-process via node-av's native bindings). On the Intel hub,
-* node-av's VA-API decode path SIGBUSes (uncatchable) on 8MP h264 and takes the
-* whole decoder runner down; ffmpeg-as-subprocess decodes the same hardware
-* cleanly because a crash is isolated to the child process.
-*
-* These helpers are extracted from the session so the argument shape is
-* unit-testable without spawning a real ffmpeg binary.
-*
-* Validated working command on the Intel hub (renderD128, 8MP h264, ~50fps,
-* exit 0):
-*
-*   ffmpeg -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 \
-*     -hwaccel_output_format vaapi -f h264 -i <in> \
-*     -vf hwdownload,format=nv12,scale=640:360,format=gray \
-*     -f rawvideo -y /dev/null
-*/
-/** Default DRM render node used for the VA-API / QSV hardware decode path. */
-var DEFAULT_VAAPI_RENDER_DEVICE = "/dev/dri/renderD128";
-/** Whether a resolved hwaccel value means "decode in software" (no `-hwaccel`). */
-function isSoftwareHwAccel(hwaccel) {
-	return hwaccel === null || hwaccel === "" || hwaccel === "none";
-}
-/** Backends whose decoded frames stay on the GPU and need an explicit
-*  `-hwaccel_output_format <m>` + `hwdownload,format=nv12` chain. */
-function needsHwDownload(hwaccel) {
-	return hwaccel === "vaapi" || hwaccel === "qsv";
-}
-/** Decode backend → its GPU scaler filter. */
-var GPU_SCALE_FILTER_BY_BACKEND = {
-	vaapi: "scale_vaapi",
-	qsv: "scale_qsv",
-	videotoolbox: "scale_vt"
-};
-/** Every GPU scaler this addon knows how to drive — used to scan `-filters`. */
-var KNOWN_GPU_SCALE_FILTERS = [
-	"scale_vaapi",
-	"scale_qsv",
-	"scale_vt"
-];
-/**
-* The GPU scaler that pairs with a decode backend, ignoring build support — a
-* static hwaccel → filter map. Returns null for software / a backend with no
-* GPU scaler (e.g. `cuda`, `drm`). Case-insensitive.
-*/
-function gpuScaleFilterForBackend(hwaccel) {
-	if (hwaccel === null) return null;
-	return GPU_SCALE_FILTER_BY_BACKEND[hwaccel.toLowerCase()] ?? null;
-}
-/**
-* Resolve the GPU scaler to use for a decode backend GIVEN the filters the
-* configured ffmpeg build actually offers ({@link parseAvailableGpuScaleFilters}).
-* Returns the filter when the backend maps to one AND the build has it; null
-* otherwise — the caller then emits the CPU-scale chain (graceful fallback).
-*/
-function resolveGpuScaleFilter(hwaccel, availableFilters) {
-	const filter = gpuScaleFilterForBackend(hwaccel);
-	if (filter === null) return null;
-	return availableFilters.has(filter) ? filter : null;
-}
-/**
-* Parse `ffmpeg -filters` stdout into the set of {@link KNOWN_GPU_SCALE_FILTERS}
-* the build offers. Matches whole filter tokens (word-boundary) so the plain
-* `scale` filter is never mistaken for a GPU scaler. PURE — the spawn lives in
-* the addon; only the parse is here so it is unit-tested.
-*/
-function parseAvailableGpuScaleFilters(filtersStdout) {
-	const present = /* @__PURE__ */ new Set();
-	for (const filter of KNOWN_GPU_SCALE_FILTERS) if (new RegExp(`\\b${filter}\\b`).test(filtersStdout)) present.add(filter);
-	return present;
-}
-/**
-* Whether the decode keeps frames on the GPU — needs `-hwaccel_output_format`
-* and an `hwdownload` in the filtergraph. VA-API / QSV always do (their decoded
-* surfaces live on the GPU); another backend only when a GPU scaler will run on
-* those surfaces (e.g. `videotoolbox` + `scale_vt`).
-*/
-function keepFramesOnGpu(hwaccel, gpuScaleFilter) {
-	return needsHwDownload(hwaccel) || gpuScaleFilter !== null;
-}
-/** Map a cap codec string to the ffmpeg `-f` input demuxer/format. */
-function codecToInputFormat(codec) {
-	switch (codec.toLowerCase()) {
-		case "h265":
-		case "hevc": return "hevc";
-		default: return "h264";
-	}
-}
-/** Map the cap-level output format to a raw ffmpeg pixel format. */
-function rawPixelForFormat(outputFormat) {
-	return outputFormat === "gray" ? "gray" : "rgb24";
-}
-/** Packed bytes-per-pixel for a raw output format (rgb24 = 3, gray = 1). */
-function channelsForPixel(pixel) {
-	return pixel === "gray" ? 1 : 3;
-}
-/**
-* The maximum output width for a given `scale` divisor — matches the node-av
-* scaler's `maxW = floor(640 / scale)` rule so both decoders produce
-* comparably-sized frames for the motion / detection pipeline.
-*/
-function maxDecodeWidth(scale) {
-	return Math.max(2, Math.floor(640 / (scale > 1 ? scale : 1)));
-}
-/**
-* Compute exact output geometry from a known source resolution — the node-av
-* rule (`outWidth = min(srcW, floor(640/scale))`, `outHeight =
-* round(outWidth*srcH/srcW)`). Provided for callers that DO know the source
-* dimensions; the live broker path leaves them to ffmpeg (`-2` height).
-*/
-function computeOutputGeometry(srcWidth, srcHeight, scale) {
-	const width = Math.min(srcWidth, maxDecodeWidth(scale));
-	return {
-		width,
-		height: Math.round(width * srcHeight / srcWidth)
-	};
-}
-/** Build the `-vf` filtergraph string for the requested hwaccel + pixel format. */
-function buildVideoFilter(hwaccel, pixel, outWidth, outHeight, maxW, gpuScaleFilter) {
-	const exact = outWidth !== void 0 && outWidth > 0 && outHeight !== void 0 && outHeight > 0;
-	if (gpuScaleFilter !== null) return `${gpuScaleFilter}=${exact ? `w=${outWidth}:h=${outHeight}` : `w=min(iw\\,${maxW}):h=-2`},hwdownload,format=nv12,format=${pixel}`;
-	const scaleAndFormat = `scale=${exact ? `${outWidth}:${outHeight}` : `min(iw\\,${maxW}):-2`},format=${pixel}`;
-	return needsHwDownload(hwaccel) ? `hwdownload,format=nv12,${scaleAndFormat}` : scaleAndFormat;
-}
-/**
-* Build the full ffmpeg argv for a decode session. PURE — no spawn, no env
-* access — so the argument shape is asserted in unit tests.
-*
-* Notes:
-* - `-loglevel info -nostats`: the session parses the muxer's `Output #0`
-*   stream line from stderr to learn the exact output W×H (the broker does not
-*   pass source geometry for the shm path). `-nostats` suppresses the periodic
-*   `frame= …` counter while keeping the one-shot Output block.
-* - The input is `pipe:0` (Annex-B packets written to stdin) in push mode, or
-*   `options.inputUrl` (the owner's restream, dialed by ffmpeg itself —
-*   `-rtsp_transport tcp` for rtsp URLs) in pull mode; the output is raw video
-*   on `pipe:1` either way.
-*/
-function buildFfmpegDecodeArgs(config, options) {
-	const inputFormat = codecToInputFormat(config.codec);
-	const pixel = rawPixelForFormat(config.outputFormat);
-	const maxW = maxDecodeWidth(config.scale);
-	const { hwaccel } = options;
-	const gpuScaleFilter = options.gpuScaleFilter ?? null;
-	const vf = buildVideoFilter(hwaccel, pixel, options.outWidth, options.outHeight, maxW, gpuScaleFilter);
-	let hwaccelArgs;
-	if (isSoftwareHwAccel(hwaccel) || hwaccel === null) hwaccelArgs = [];
-	else {
-		hwaccelArgs = ["-hwaccel", hwaccel];
-		if (needsHwDownload(hwaccel)) hwaccelArgs.push("-hwaccel_device", options.renderDevice ?? "/dev/dri/renderD128");
-		if (keepFramesOnGpu(hwaccel, gpuScaleFilter)) hwaccelArgs.push("-hwaccel_output_format", hwaccel);
-	}
-	const inputArgs = options.inputUrl !== void 0 ? [
-		...options.inputUrl.startsWith("rtsp") ? ["-rtsp_transport", "tcp"] : [],
-		"-i",
-		options.inputUrl
-	] : [
-		"-f",
-		inputFormat,
-		"-i",
-		"pipe:0"
-	];
-	return [
-		...logBannerArgs("info"),
-		"-nostats",
-		"-fflags",
-		"+nobuffer+flush_packets",
-		"-flags",
-		"low_delay",
-		"-probesize",
-		"1M",
-		"-analyzeduration",
-		"0",
-		...hwaccelArgs,
-		...inputArgs,
-		"-vf",
-		vf,
-		"-f",
-		"rawvideo",
-		"-pix_fmt",
-		pixel,
-		"pipe:1"
-	];
-}
-/**
-* Parse the exact output geometry from ffmpeg's stderr. The muxer prints an
-* `Output #0, rawvideo …` block whose `Stream #0:0: Video: rawvideo …, <fmt>,
-* WIDTHxHEIGHT …` line carries the scaled dimensions. Gating on the `Output #`
-* marker avoids picking up the INPUT stream's (source) resolution, which is
-* printed earlier.
-*
-* Returns `null` until the Output block with a `WxH` token has been seen.
-*/
-function parseFfmpegOutputDims(stderr) {
-	const outputIdx = stderr.indexOf("Output #");
-	if (outputIdx < 0) return null;
-	const match = stderr.slice(outputIdx).match(/(\d{2,5})x(\d{2,5})/);
-	if (!match) return null;
-	const width = Number(match[1]);
-	const height = Number(match[2]);
-	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) return null;
-	return {
-		width,
-		height
-	};
-}
-/**
-* Pick the first kernel-preferred `-hwaccel` method the configured ffmpeg build
-* actually supports, or `null` (software) when it supports none. Mirrors the
-* broker's `pickDecodeHwAccel` (`ffmpeg-invocation.ts`) so the decoder gates
-* decode-hwaccel against the same probed evidence:
-* - empty `preferred` → `null` (software);
-* - empty `supportedMethods` (probe miss) → keep the top preference and let the
-*   session's per-child software fallback cover a genuine failure;
-* - otherwise the first preference the build supports, or `null`.
-*/
-function pickDecodeHwAccel(preferred, supportedMethods) {
-	if (preferred.length === 0) return null;
-	if (supportedMethods.length === 0) return preferred[0] ?? null;
-	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
-	return preferred.find((name) => supported.has(name.toLowerCase())) ?? null;
-}
-/**
-* Canonical decode-hwaccel preference order for the ffmpeg-subprocess decoder.
-*
-* `vaapi` is ranked ABOVE `qsv` deliberately: on the Intel hub the `qsv` decode
-* child exits early (`code=171`, no frames) while the `vaapi` path decodes 8MP
-* h264 cleanly at ~50fps. The kernel probe (`resolveHwAccel`) tends to surface
-* `qsv` first on Intel, so we re-rank its result through this table before
-* building the attempt chain. `videotoolbox` leads for macOS; `cuda` / `nvdec`
-* trail for NVIDIA. A method not listed here keeps its incoming relative order,
-* placed AFTER every ranked one.
-*/
-var DECODE_HWACCEL_RANK = [
-	"videotoolbox",
-	"vaapi",
-	"qsv",
-	"cuda",
-	"nvdec",
-	"d3d11va",
-	"dxva2",
-	"amf",
-	"vdpau",
-	"drm"
-];
-/** Rank index for {@link DECODE_HWACCEL_RANK} — unranked methods sort last. */
-function decodeHwAccelRankIndex(method) {
-	const idx = DECODE_HWACCEL_RANK.indexOf(method.toLowerCase());
-	return idx < 0 ? DECODE_HWACCEL_RANK.length : idx;
-}
-/**
-* Build the ORDERED list of hardware `-hwaccel` methods to attempt for an
-* `'auto'` decode session, best-first. The session walks this chain on an
-* early-exit-with-no-frames and only falls to software once it is exhausted.
-*
-* Strategy:
-* - Seed candidates from the kernel-preferred order UNION the canonical rank
-*   UNION the build's supported list, so a method the kernel omitted but the
-*   build supports (the Intel `vaapi` case — kernel surfaces only `qsv`) is
-*   still attempted.
-* - When the build's supported-method list is known (non-empty), keep only
-*   methods it actually offers; on a probe miss (empty) keep just the kernel
-*   preferences (avoid blindly spawning every backend).
-* - Re-rank the survivors by {@link DECODE_HWACCEL_RANK} so `vaapi` precedes
-*   `qsv`. A supported method not in the rank table keeps its position AFTER
-*   every ranked one (stable sort). Returns lowercased method names; empty ⇒
-*   pure software.
-*/
-function rankDecodeHwAccels(preferred, supportedMethods) {
-	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
-	const hasSupportList = supported.size > 0;
-	const pool = hasSupportList ? [
-		...preferred,
-		...DECODE_HWACCEL_RANK,
-		...supportedMethods
-	] : [...preferred];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	for (const raw of pool) {
-		const method = raw.toLowerCase();
-		if (seen.has(method)) continue;
-		seen.add(method);
-		if (hasSupportList && !supported.has(method)) continue;
-		candidates.push(method);
-	}
-	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
-}
-//#endregion
 //#region src/decoder-ffmpeg/frame-stream-splitter.ts
 var FrameStreamSplitter = class {
 	frameSize;
@@ -894,7 +602,8 @@ function probeGpuScaleFilters(ffmpegPath, logger) {
 var FRAME_BUFFER_CAPACITY = 32;
 var DEFAULT_DECODER_FFMPEG_ADDON_CONFIG = {
 	...DEFAULT_DECODER_HWACCEL_CONFIG,
-	backend: DEFAULT_DECODER_BACKEND
+	backend: DEFAULT_DECODER_BACKEND,
+	binaryPath: ""
 };
 /** The two selectable decoder backends, in default-first order. */
 var DECODER_BACKEND_OPTIONS = [{
@@ -956,27 +665,40 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 			title: "Hardware acceleration",
 			tab: "decoder",
 			description: "Backend used by ffmpeg-subprocess decoder sessions. \"Auto\" defers to the probed best (VA-API on Intel); \"Off\" forces pure software. Only the VA-API hardware path is validated — other concrete backends degrade to software. Changes apply to NEW sessions.",
-			fields: [this.field({
-				type: "select",
-				key: "hwaccel",
-				label: "Preferred backend",
-				options: [...HWACCEL_OPTIONS],
-				default: "auto",
-				immediate: true
-			}), this.field({
-				type: "text",
-				key: "probedBestHwaccel",
-				label: "Probed best",
-				description: "Auto-detected best decoder backend on this host. Click the refresh icon to re-run the probe.",
-				readonlyField: true,
-				default: "",
-				perNode: true,
-				actions: [{
-					action: "reprobe-hwaccel",
-					icon: "refresh-cw",
-					tooltip: "Re-probe hwaccel"
-				}]
-			})]
+			fields: [
+				this.field({
+					type: "select",
+					key: "hwaccel",
+					label: "Preferred backend",
+					options: [...HWACCEL_OPTIONS],
+					default: "auto",
+					immediate: true,
+					perNode: true
+				}),
+				this.field({
+					type: "text",
+					key: "probedBestHwaccel",
+					label: "Probed best",
+					description: "Auto-detected best decoder backend on this host. Click the refresh icon to re-run the probe.",
+					readonlyField: true,
+					default: "",
+					perNode: true,
+					actions: [{
+						action: "reprobe-hwaccel",
+						icon: "refresh-cw",
+						tooltip: "Re-probe hwaccel"
+					}]
+				}),
+				this.field({
+					type: "text",
+					key: "binaryPath",
+					label: "ffmpeg binary path (override)",
+					description: "Optional per-node override for the ffmpeg binary. Leave empty to auto-provision a portable static ffmpeg on this node (recommended). Per-node because the path differs per OS/arch.",
+					placeholder: "ffmpeg",
+					default: "",
+					perNode: true
+				})
+			]
 		}] });
 	}
 	async onInitialize() {
@@ -1018,10 +740,8 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 	* decoder cap and a later session spawn re-runs the ensure.
 	*/
 	async resolveFfmpegBinaryPath() {
-		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			if (typeof bp === "string" && bp.trim().length > 0) return bp;
-		} catch {}
+		const override = this.config.binaryPath;
+		if (typeof override === "string" && override.trim().length > 0) return override;
 		try {
 			return await this.ctx.deps.ensureFfmpeg();
 		} catch (err) {
@@ -1037,21 +757,51 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 	* - `'none'` → `[]` (pure software).
 	* - explicit backend → `[<backend>]` (forced; the session still falls to
 	*   software if that one child fails).
-	* - `'auto'` → asks `platform-probe.resolveHwAccel` for the kernel-preferred
-	*   order + the node's supported `-hwaccel` methods
-	*   (`getHardwareDecodeAccels`), then ranks them via {@link rankDecodeHwAccels}
-	*   (vaapi ABOVE qsv, since qsv is broken on the Intel stack while vaapi
-	*   works). On a probe error → `[]` (software).
+	* - `'auto'` → the LOCAL node's preferred order from `ctx.kernel.hwaccel` —
+	*   the in-process resolver every forked child (hub / worker / agent) is
+	*   given, which derives the backend from `os.platform()` + a GPU-vendor probe
+	*   (darwin → `videotoolbox`; Intel → `qsv,vaapi`; NVIDIA → `cuda,nvdec`).
+	*   Ranked via {@link rankDecodeHwAccels} (vaapi ABOVE qsv, since qsv is broken
+	*   on the Intel stack while vaapi works). On a resolver error → `[]`
+	*   (software).
+	*
+	* Two things this deliberately does NOT do:
+	* - It does NOT call the `platform-probe` singleton cap. Its per-node
+	*   `nodePin` does not survive a forked agent child's link chain, so a pinned
+	*   read resolves to the HUB's elected singleton and returns the hub's
+	*   hardware — a Mac decoder was handed the hub's Intel `vaapi/qsv/...` chain
+	*   (no `videotoolbox`) and fell all the way to software h265.
+	* - It does NOT probe `ffmpeg -hwaccels` (nor node-av) to intersect the list.
+	*   The accelerator is deterministic from the host, which the kernel resolver
+	*   already knows in-process — no subprocess, no cross-process round-trip. The
+	*   rare case where the resolved backend is not usable by the actual ffmpeg
+	*   build is covered by the session's per-child runtime fallback (advance to
+	*   the next chain entry, else software). This mirrors how Scrypted resolves
+	*   hwaccel (static `os.platform()` map + try-then-fall-back), not a native
+	*   capability enumeration.
+	*
+	* macOS special-case: the resolved `videotoolbox` is emitted as `-hwaccel
+	* auto`, NOT explicit `-hwaccel videotoolbox`. Explicit videotoolbox tears the
+	* ffmpeg child down under MULTIPLE concurrent decode streams (documented by
+	* Scrypted NVR's ffmpeg path; our Mac decodes many cameras at once — exactly
+	* that case). `auto` lets ffmpeg pick VideoToolbox internally and auto-download
+	* frames to software (no GPU surface to dispose, no `scale_vt`). The in-process
+	* node-av decoder (`decoder-nodeav`) still uses explicit videotoolbox — this
+	* substitution is specific to the ffmpeg-subprocess decode.
 	*/
 	async resolveDecodeHwaccelChain() {
 		const pref = this.config.hwaccel;
 		if (pref === "none") return [];
 		if (pref !== "auto") return [pref];
 		try {
-			const pin = nodePin(this.resolveLocalNodeId());
-			const res = await this.ctx.api.platformProbe.resolveHwAccel.query({ prefer: null }, pin);
-			const supported = await this.ctx.api.platformProbe.getHardwareDecodeAccels.query(void 0, pin);
-			return rankDecodeHwAccels(res.preferred, supported.methods);
+			const resolver = this.ctx.kernel.hwaccel;
+			if (!resolver) {
+				this.ctx.logger.warn("ffmpeg: no local kernel hwaccel resolver — software decode");
+				return [];
+			}
+			const chain = rankDecodeHwAccels((await resolver.resolve(null)).preferred, []);
+			if (process.platform === "darwin") return chain.map((method) => method === "videotoolbox" ? "auto" : method);
+			return chain;
 		} catch (err) {
 			this.ctx.logger.warn("ffmpeg: decode-hwaccel probe failed — software decode", { meta: { error: err instanceof Error ? err.message : String(err) } });
 			return [];
@@ -1066,7 +816,7 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 		}
 		try {
 			const res = await resolver.resolve();
-			const backend = res.preferred[0] ?? "none";
+			const backend = rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
 			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,

package/dist/decoder-nodeav/index.js

@@ -2,8 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Biq62zt4.js");
-const require_frame_ring_sink = require("../frame-ring-sink-9J0wCdLF.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
+const require_frame_ring_sink = require("../frame-ring-sink-8LLV-cvH.js");
+const require_ffmpeg_args = require("../ffmpeg-args-D6h1edXK.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");
 //#region src/decoder-nodeav/scaler-geometry.ts
@@ -919,7 +920,8 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 				label: "Preferred backend",
 				options: [...require_dist.HWACCEL_OPTIONS],
 				default: "auto",
-				immediate: true
+				immediate: true,
+				perNode: true
 			}), this.field({
 				type: "text",
 				key: "probedBestHwaccel",
@@ -976,7 +978,7 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 		}
 		try {
 			const res = await resolver.resolve();
-			const backend = res.preferred[0] ?? "none";
+			const backend = require_ffmpeg_args.rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
 			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,

package/dist/decoder-nodeav/index.mjs

@@ -1,5 +1,6 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-C6_wgXqF.mjs";
-import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, r as makeSegmentName, t as DecoderFrameRingSink } from "../frame-ring-sink-Cs9vby6v.mjs";
+import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-DjuGmyG9.mjs";
+import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, r as makeSegmentName, t as DecoderFrameRingSink } from "../frame-ring-sink-ClEWjiRU.mjs";
+import { f as rankDecodeHwAccels } from "../ffmpeg-args-C5GPp8Cw.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
 //#region src/decoder-nodeav/scaler-geometry.ts
@@ -915,7 +916,8 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 				label: "Preferred backend",
 				options: [...HWACCEL_OPTIONS],
 				default: "auto",
-				immediate: true
+				immediate: true,
+				perNode: true
 			}), this.field({
 				type: "text",
 				key: "probedBestHwaccel",
@@ -972,7 +974,7 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		}
 		try {
 			const res = await resolver.resolve();
-			const backend = res.preferred[0] ?? "none";
+			const backend = rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
 			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,