@camstack/addon-pipeline 1.1.27 → 1.1.29

package/dist/decoder-ffmpeg/index.js

@@ -2,305 +2,13 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DAIlCdAx.js");
-const require_frame_ring_sink = require("../frame-ring-sink-BbzrqTWj.js");
-const require_frame_dropper = require("../frame-dropper-7RTo_YyG.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");
+const require_frame_dropper = require("../frame-dropper-DKLM6pMz.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");
 let node_child_process = require("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 [
-		...require_frame_dropper.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;
@@ -490,13 +198,13 @@ var FfmpegDecoderSession = class {
 		this.nodeId = options?.nodeId ?? "local";
 		this.renderDevice = options?.renderDevice;
 		this.ffmpegPath = options?.ffmpegPath ?? "ffmpeg";
-		const seededChain = options?.hwaccelChain ?? (options?.hwaccel != null && !isSoftwareHwAccel(options.hwaccel) ? [options.hwaccel] : []);
-		this.hwaccelChain = seededChain.filter((m) => !isSoftwareHwAccel(m));
+		const seededChain = options?.hwaccelChain ?? (options?.hwaccel != null && !require_ffmpeg_args.isSoftwareHwAccel(options.hwaccel) ? [options.hwaccel] : []);
+		this.hwaccelChain = seededChain.filter((m) => !require_ffmpeg_args.isSoftwareHwAccel(m));
 		this.hwaccel = this.currentHwAccel();
 		this.availableGpuScaleFilters = options?.availableGpuScaleFilters ?? /* @__PURE__ */ new Set();
 		this.onGpuScaleUnsupported = options?.onGpuScaleUnsupported;
-		this.pixel = rawPixelForFormat(config.outputFormat);
-		this.channels = channelsForPixel(this.pixel);
+		this.pixel = require_ffmpeg_args.rawPixelForFormat(config.outputFormat);
+		this.channels = require_ffmpeg_args.channelsForPixel(this.pixel);
 		this.frameFormat = this.pixel === "gray" ? "gray" : "rgb";
 		this.frameDropper = new require_frame_dropper.FrameDropper(config.maxFps);
 	}
@@ -551,8 +259,8 @@ var FfmpegDecoderSession = class {
 		this.outWidth = 0;
 		this.outHeight = 0;
 		this.frameSize = 0;
-		this.activeGpuScaleFilter = this.gpuScaleEnabled ? resolveGpuScaleFilter(this.hwaccel, this.availableGpuScaleFilters) : null;
-		const args = buildFfmpegDecodeArgs({
+		this.activeGpuScaleFilter = this.gpuScaleEnabled ? require_ffmpeg_args.resolveGpuScaleFilter(this.hwaccel, this.availableGpuScaleFilters) : null;
+		const args = require_ffmpeg_args.buildFfmpegDecodeArgs({
 			codec: this.config.codec,
 			scale: this.config.scale,
 			outputFormat: this.config.outputFormat
@@ -621,7 +329,7 @@ var FfmpegDecoderSession = class {
 	handleExit(code, signal) {
 		if (this.destroyed) return;
 		const diedFast = Date.now() - this.spawnedAtMs < HWACCEL_FALLBACK_WINDOW_MS;
-		if (!isSoftwareHwAccel(this.hwaccel) && this.outputFrames === 0 && diedFast) {
+		if (!require_ffmpeg_args.isSoftwareHwAccel(this.hwaccel) && this.outputFrames === 0 && diedFast) {
 			if (this.activeGpuScaleFilter !== null) {
 				const brokenFilter = this.activeGpuScaleFilter;
 				this.gpuScaleEnabled = false;
@@ -640,7 +348,7 @@ var FfmpegDecoderSession = class {
 			this.hwaccelIndex += 1;
 			this.hwaccel = this.currentHwAccel();
 			this.gpuScaleEnabled = true;
-			const next = isSoftwareHwAccel(this.hwaccel) ? "software" : this.hwaccel;
+			const next = require_ffmpeg_args.isSoftwareHwAccel(this.hwaccel) ? "software" : this.hwaccel;
 			this.logger.warn("ffmpeg decoder: hwaccel child exited early with no frames — trying next decode path", { meta: {
 				failed,
 				next,
@@ -889,13 +597,26 @@ function probeGpuScaleFilters(ffmpegPath, logger) {
 			done(/* @__PURE__ */ new Set());
 		});
 		child.on("exit", () => {
-			done(parseAvailableGpuScaleFilters(stdout));
+			done(require_ffmpeg_args.parseAvailableGpuScaleFilters(stdout));
 		});
 	});
 }
 //#endregion
 //#region src/decoder-ffmpeg/addon/index.ts
 var FRAME_BUFFER_CAPACITY = 32;
+var DEFAULT_DECODER_FFMPEG_ADDON_CONFIG = {
+	...require_dist.DEFAULT_DECODER_HWACCEL_CONFIG,
+	backend: require_frame_ring_sink.DEFAULT_DECODER_BACKEND,
+	binaryPath: ""
+};
+/** The two selectable decoder backends, in default-first order. */
+var DECODER_BACKEND_OPTIONS = [{
+	value: "ffmpeg",
+	label: "ffmpeg (subprocess — crash-isolated, default)"
+}, {
+	value: "nodeav",
+	label: "node-av (in-process FFmpeg bindings)"
+}];
 var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	sessions = /* @__PURE__ */ new Map();
 	frameBuffers = /* @__PURE__ */ new Map();
@@ -926,38 +647,66 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	*/
 	unsupportedGpuScaleFilters = /* @__PURE__ */ new Set();
 	constructor() {
-		super(require_dist.DEFAULT_DECODER_HWACCEL_CONFIG);
+		super(DEFAULT_DECODER_FFMPEG_ADDON_CONFIG);
 	}
 	globalSettingsSchema() {
 		return this.schema({ sections: [{
-			id: "hwaccel",
-			title: "Hardware acceleration",
+			id: "backend",
+			title: "Decoder backend",
 			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.",
+			description: "Which decoder addon provides the decoder capability on this node — per-node selection, stored centrally on the hub. Selection is decided once at addon init (registration-time, race-free), so a change applies at the next restart of the decoder addons on the node.",
 			fields: [this.field({
 				type: "select",
-				key: "hwaccel",
-				label: "Preferred backend",
-				options: [...require_dist.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: "",
-				actions: [{
-					action: "reprobe-hwaccel",
-					icon: "refresh-cw",
-					tooltip: "Re-probe hwaccel"
-				}]
+				key: "backend",
+				label: "Backend",
+				options: [...DECODER_BACKEND_OPTIONS],
+				default: require_frame_ring_sink.DEFAULT_DECODER_BACKEND,
+				immediate: true,
+				perNode: true
 			})]
+		}, {
+			id: "hwaccel",
+			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: [...require_dist.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() {
-		const backend = await require_frame_ring_sink.resolveDecoderBackend(this.ctx.settings, this.resolveLocalNodeId(), this.ctx.logger);
+		const backend = await require_frame_ring_sink.resolveDecoderBackend(this.ctx.api, this.resolveLocalNodeId(), this.ctx.logger);
 		if (backend !== "ffmpeg") {
 			this.ctx.logger.info("ffmpeg decoder: this node selects a different decoder backend — standing down (no decoder provider registered)", { meta: { selectedBackend: backend } });
 			return [];
@@ -995,10 +744,8 @@ var DecoderFfmpegAddon = class extends require_dist.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) {
@@ -1014,20 +761,51 @@ var DecoderFfmpegAddon = class extends require_dist.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 res = await this.ctx.api.platformProbe.resolveHwAccel.query({ prefer: null });
-			const supported = await this.ctx.api.platformProbe.getHardwareDecodeAccels.query();
-			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 = require_ffmpeg_args.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 [];
@@ -1037,13 +815,13 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		const resolver = this.ctx.kernel.hwaccel;
 		if (!resolver) {
 			this.ctx.logger.warn("reprobeHwaccel: no kernel hwaccel resolver — returning none");
-			await this.ctx.settings?.writeAddonStore({ probedBestHwaccel: "none" });
+			await this.updateGlobalSettings({ probedBestHwaccel: "none" });
 			return { backend: "none" };
 		}
 		try {
 			const res = await resolver.resolve();
-			const backend = res.preferred[0] ?? "none";
-			await this.ctx.settings?.writeAddonStore({ probedBestHwaccel: backend });
+			const backend = require_ffmpeg_args.rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
+			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,
 				rationale: res.rationale,
@@ -1052,7 +830,7 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 			return { backend };
 		} catch (err) {
 			this.ctx.logger.warn("reprobeHwaccel failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			await this.ctx.settings?.writeAddonStore({ probedBestHwaccel: "none" });
+			await this.updateGlobalSettings({ probedBestHwaccel: "none" });
 			return { backend: "none" };
 		}
 	}
@@ -1119,7 +897,7 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		};
 	}
 	wireCallbackSink(sessionId, session) {
-		const ringBuffer = new require_dist.RingBuffer(FRAME_BUFFER_CAPACITY);
+		const ringBuffer = new require_frame_ring_sink.NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
 		this.frameBuffers.set(sessionId, ringBuffer);
 		return session.onFrame((frame) => {
 			const { format } = frame;
@@ -1137,7 +915,7 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		});
 	}
 	wireShmSink(sessionId, session) {
-		const handleRing = new require_dist.RingBuffer(FRAME_BUFFER_CAPACITY);
+		const handleRing = new require_frame_ring_sink.NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
 		this.handleBuffers.set(sessionId, handleRing);
 		return session.onFrameHandle((frame) => {
 			handleRing.push(frame.handle);
@@ -1149,6 +927,8 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		if (!session) throw new Error(`decoder-ffmpeg: unknown sessionId ${sessionId}`);
 		const unsub = this.unsubscribers.get(sessionId);
 		if (unsub) unsub();
+		this.frameBuffers.get(sessionId)?.cancel();
+		this.handleBuffers.get(sessionId)?.cancel();
 		await session.destroy();
 		this.sessions.delete(sessionId);
 		this.frameBuffers.delete(sessionId);
@@ -1186,12 +966,14 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
 		const ringBuffer = this.frameBuffers.get(input.sessionId);
 		if (!ringBuffer) return [];
+		if (ringBuffer.size === 0 && input.waitMs) await ringBuffer.waitForItem(input.waitMs);
 		return ringBuffer.drain(input.maxCount);
 	}
 	async pullHandles(input) {
 		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
 		const handleRing = this.handleBuffers.get(input.sessionId);
 		if (!handleRing) return [];
+		if (handleRing.size === 0 && input.waitMs) await handleRing.waitForItem(input.waitMs);
 		return handleRing.drain(input.maxCount);
 	}
 	async updateConfig(input) {
@@ -1251,17 +1033,17 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
-exports.DECODE_HWACCEL_RANK = DECODE_HWACCEL_RANK;
-exports.DEFAULT_VAAPI_RENDER_DEVICE = DEFAULT_VAAPI_RENDER_DEVICE;
+exports.DECODE_HWACCEL_RANK = require_ffmpeg_args.DECODE_HWACCEL_RANK;
+exports.DEFAULT_VAAPI_RENDER_DEVICE = require_ffmpeg_args.DEFAULT_VAAPI_RENDER_DEVICE;
 exports.DecoderFfmpegAddon = DecoderFfmpegAddon;
 exports.FfmpegDecoderSession = FfmpegDecoderSession;
-exports.buildFfmpegDecodeArgs = buildFfmpegDecodeArgs;
-exports.channelsForPixel = channelsForPixel;
-exports.codecToInputFormat = codecToInputFormat;
-exports.computeOutputGeometry = computeOutputGeometry;
+exports.buildFfmpegDecodeArgs = require_ffmpeg_args.buildFfmpegDecodeArgs;
+exports.channelsForPixel = require_ffmpeg_args.channelsForPixel;
+exports.codecToInputFormat = require_ffmpeg_args.codecToInputFormat;
+exports.computeOutputGeometry = require_ffmpeg_args.computeOutputGeometry;
 exports.default = DecoderFfmpegAddon;
-exports.maxDecodeWidth = maxDecodeWidth;
-exports.parseFfmpegOutputDims = parseFfmpegOutputDims;
-exports.pickDecodeHwAccel = pickDecodeHwAccel;
-exports.rankDecodeHwAccels = rankDecodeHwAccels;
-exports.rawPixelForFormat = rawPixelForFormat;
+exports.maxDecodeWidth = require_ffmpeg_args.maxDecodeWidth;
+exports.parseFfmpegOutputDims = require_ffmpeg_args.parseFfmpegOutputDims;
+exports.pickDecodeHwAccel = require_ffmpeg_args.pickDecodeHwAccel;
+exports.rankDecodeHwAccels = require_ffmpeg_args.rankDecodeHwAccels;
+exports.rawPixelForFormat = require_ffmpeg_args.rawPixelForFormat;