@camstack/addon-pipeline 1.1.34 → 1.1.35

package/dist/decoder-ffmpeg/index.mjs

@@ -1,1097 +0,0 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-CfSORkv2.mjs";
-import { c as DEFAULT_DECODER_BACKEND, i as NotifyingRingBuffer, n as RING_BUDGET_MB, s as resolveOwnDecoderBackend, t as DecoderFrameRingSink } from "../frame-ring-sink-1aLGcNNf.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-CpeRWwL4.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/frame-stream-splitter.ts
-var FrameStreamSplitter = class {
-	frameSize;
-	ctl;
-	/** Whether a frame is currently being filled (partially received). */
-	open = false;
-	/** The current frame's fill target, or `null` when the open frame is dropped. */
-	target = null;
-	/** Bytes already written into the current frame. */
-	filled = 0;
-	constructor(frameSize, ctl) {
-		if (!Number.isInteger(frameSize) || frameSize <= 0) throw new Error(`FrameStreamSplitter: frameSize must be a positive integer, got ${frameSize}`);
-		this.frameSize = frameSize;
-		this.ctl = ctl;
-	}
-	/** True while a frame has been started (a live slot may be open) but not yet
-	*  completed — the session aborts an open slot on teardown. */
-	get hasOpenFrame() {
-		return this.open && this.target !== null;
-	}
-	/**
-	* Consume a stdout chunk, emitting every frame boundary it completes. A chunk
-	* may finish the open frame, contain several whole frames, and/or leave a
-	* partial frame buffered for the next chunk.
-	*/
-	push(chunk) {
-		const n = chunk.length;
-		let off = 0;
-		while (off < n) {
-			if (!this.open) {
-				this.target = this.ctl.startFrame();
-				this.open = true;
-				this.filled = 0;
-			}
-			const take = Math.min(this.frameSize - this.filled, n - off);
-			if (this.target !== null) chunk.copy(this.target, this.filled, off, off + take);
-			this.filled += take;
-			off += take;
-			if (this.filled === this.frameSize) {
-				const finished = this.target;
-				this.open = false;
-				this.target = null;
-				this.filled = 0;
-				if (finished !== null) this.ctl.finishFrame(finished);
-				else this.ctl.dropFrame();
-			}
-		}
-	}
-};
-//#endregion
-//#region src/decoder-ffmpeg/ffmpeg-decoder-session.ts
-/**
-* FfmpegDecoderSession — an `IDecoderSession` that decodes video in an **ffmpeg
-* subprocess** and feeds the shared-memory frame ring (Phase 5 / D9), the same
-* ring `decoder-nodeav` writes into.
-*
-* Why a subprocess: on the Intel hub, node-av's in-process VA-API decode path
-* SIGBUSes (uncatchable) on 8MP h264 and kills the whole decoder runner. ffmpeg
-* decodes the identical hardware cleanly because it runs out-of-process — a
-* crashing child just stops producing frames; the addon survives and the
-* frame-plane rotates/retries.
-*
-* Data flow per session:
-*   Annex-B packets → ffmpeg stdin (pipe:0)
-*   ffmpeg  → `-vf <scale_vaapi=…,hwdownload,… | hwdownload,…,scale=…>` (GPU or
-*             CPU scale, per {@link buildFfmpegDecodeArgs})
-*   raw video → ffmpeg stdout (pipe:1) → a {@link FrameStreamSplitter} that fills
-*             each frame's bytes DIRECTLY into its shm ring slot (zero-copy
-*             `beginFrame`/`commitFrame`) → `FrameHandle` (shm mode), or into a
-*             per-frame buffer → `DecodedFrame` via `onFrame` (callback mode).
-*             No `Buffer.concat` accumulator, one copy per byte, none for dropped
-*             frames.
-*
-* Output geometry: the broker does not pass source width/height for the shm
-* path, so ffmpeg picks the height (`scale=min(iw\,maxW):-2`) and the session
-* learns the exact output W×H by parsing the muxer's `Output #0` stderr block
-* ({@link parseFfmpegOutputDims}). Until dims are known, stdout is buffered.
-*/
-var noopLogger = {
-	debug() {},
-	info() {},
-	warn() {},
-	error() {},
-	child() {
-		return noopLogger;
-	},
-	withTags() {
-		return noopLogger;
-	}
-};
-/** A hardware child that dies faster than this (with no frames) advances the
-*  session to the NEXT decode path (next hwaccel, else software) — a genuine
-*  hwaccel init failure (missing render node, unsupported codec on GPU, the
-*  Intel `qsv` `code=171`) surfaces this early. */
-var HWACCEL_FALLBACK_WINDOW_MS = 4e3;
-/**
-* Delay before a PULL-MODE session re-dials its input URL after the child
-* exits (RTSP EOF, restream teardown, network blip). Push mode never
-* self-respawns on a plain exit — the broker's packet feed drives recovery —
-* but a pull-mode child owns its own input, so the session must re-dial or a
-* single EOF would silence it forever. The delay turns a hard-down source
-* into a slow probe instead of a spawn storm; the consumer tearing the
-* session down (`destroy`) cancels the pending re-dial.
-*/
-var PULL_REDIAL_DELAY_MS = 3e3;
-/**
-* Safety ceiling for the current-GOP replay buffer (push mode). A GOP resets on
-* every keyframe so this is never reached by a well-behaved stream; it only
-* bounds a pathological long/no-keyframe stream. When exceeded, only the
-* keyframe is retained — enough to re-prime the decoder's SPS/PPS on a re-spawn.
-*/
-var MAX_GOP_BUFFER_BYTES = 16 * 1024 * 1024;
-var FfmpegDecoderSession = class {
-	config;
-	logger;
-	frameSink;
-	nodeId;
-	renderDevice;
-	ffmpegPath;
-	/**
-	* Ordered hardware decode paths to attempt, best-first. Empty ⇒ software
-	* only. The session walks it via {@link hwaccelIndex}; an index past the end
-	* means software (`null`).
-	*/
-	hwaccelChain;
-	hwaccelIndex = 0;
-	hwaccel;
-	/** GPU scalers the build offers; drives whether decode scales on the GPU. */
-	availableGpuScaleFilters;
-	onGpuScaleUnsupported;
-	/**
-	* Whether the CURRENT backend attempt may use its GPU scaler. Starts true for
-	* each backend; a GPU-scale child that dies immediately with no frames flips
-	* it false and the SAME backend is retried on the CPU-scale chain (so a broken
-	* GPU scaler degrades to hw-decode + CPU-scale, never to software decode).
-	*/
-	gpuScaleEnabled = true;
-	/** The GPU scaler the live child was spawned with, or null (CPU scale). */
-	activeGpuScaleFilter = null;
-	process = null;
-	spawnedAtMs = 0;
-	/**
-	* Whether a spawn has ever been attempted. Drives the LAZY first spawn
-	* (first `pushPacket` / `openStream`) and preserves the recovery semantics
-	* afterwards: a push-mode child that later dies is NOT respawned by the
-	* packet feed (the consumer / frame-plane self-heal recreates the session),
-	* and `updateConfig` only restarts a session that has already spawned.
-	*/
-	spawnAttempted = false;
-	/**
-	* PULL-MODE input URL (P2b). `null` = push mode (packets via stdin — the
-	* default). Set by {@link openStream}; every (re)spawn since reads this URL
-	* directly instead of `pipe:0`. A session is push-mode or pull-mode for its
-	* whole life — `openStream` on a packet-fed session throws.
-	*/
-	pullUrl = null;
-	/** Pending pull-mode re-dial timer (armed on a pull child exit). */
-	pullRedialTimer = null;
-	/**
-	* Splits ffmpeg's raw stdout byte stream into frames, filling each DIRECTLY
-	* into its shm slot (zero-copy) — created once the output geometry is known.
-	*/
-	splitter = null;
-	/** Stdout chunks received BEFORE geometry is known — replayed into the
-	*  splitter once `frameSize` is learned. A short-lived list (no concat). */
-	pendingStdout = [];
-	/** The shm ring slot the splitter is currently filling, if any — aborted on
-	*  respawn / teardown so a half-filled slot never publishes. */
-	openSlot = null;
-	stderrAccum = "";
-	destroyed = false;
-	pixel;
-	channels;
-	/** The cap-facing raw format label (`'rgb'` / `'gray'`) stamped into frames. */
-	frameFormat;
-	outWidth = 0;
-	outHeight = 0;
-	frameSize = 0;
-	frameRingSink = null;
-	frameCallbacks = /* @__PURE__ */ new Set();
-	handleCallbacks = /* @__PURE__ */ new Set();
-	frameDropper;
-	inputPackets = 0;
-	/**
-	* Current-GOP Annex-B packet bytes (push mode), from the most recent keyframe
-	* forward. Replayed keyframe-first into every freshly-spawned child so a
-	* hwaccel cascade re-spawn (`vaapi → qsv → software`) or a config restart
-	* resumes on a keyframe instead of the live mid-GOP P-frame the dead child had
-	* already consumed — which the fallback child would otherwise choke on
-	* (`non-existing PPS 0`) until the next live keyframe. Mirrors the reference
-	* NVR libav decoder, which replays its buffered packet list to each hwaccel
-	* candidate. Reset on each keyframe; unused in pull mode.
-	*/
-	gopBuffer = [];
-	gopBufferBytes = 0;
-	outputFrames = 0;
-	droppedFrames = 0;
-	startTime = Date.now();
-	constructor(config, logger = noopLogger, options) {
-		this.config = { ...config };
-		const sessionTags = {};
-		if (typeof config.deviceId === "number") sessionTags["deviceId"] = config.deviceId;
-		if (typeof config.tag === "string" && config.tag.length > 0) sessionTags["tag"] = config.tag;
-		this.logger = Object.keys(sessionTags).length > 0 ? logger.withTags(sessionTags) : logger;
-		this.frameSink = options?.frameSink ?? "callback";
-		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));
-		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.frameFormat = this.pixel === "gray" ? "gray" : "rgb";
-		this.frameDropper = new FrameDropper(config.maxFps);
-	}
-	/** Exposed so the owning addon can surface ring stats via `getShmStats`. */
-	get frameRingSinkOrNull() {
-		return this.frameRingSink;
-	}
-	get isPullMode() {
-		return this.pullUrl !== null;
-	}
-	/**
-	* Switch the session to PULL MODE: (re)spawn ffmpeg reading `url` directly
-	* (`-rtsp_transport tcp -i <url>` for rtsp) instead of stdin. The whole
-	* output path (filtergraph, rawvideo pipe, shm ring sink) is unchanged.
-	*
-	* - Calling it again re-dials with the FRESH url (a hub restream bounce
-	*   mints a new token URL — never cache the old one).
-	* - Calling it on a session already fed via `pushPacket` throws: a session
-	*   is push-mode or pull-mode, never both (mixing inputs would corrupt the
-	*   decode).
-	*/
-	async openStream(url) {
-		if (this.destroyed) return;
-		if (this.pullUrl === null && this.inputPackets > 0) throw new Error("ffmpeg decoder: openStream on a push-fed session — a session is push-mode or pull-mode, never both");
-		this.pullUrl = url;
-		this.logger.info("ffmpeg decoder: pull-mode openStream — dialing input URL", { meta: { url } });
-		this.spawnFfmpeg();
-	}
-	ensureFrameRingSink() {
-		if (this.frameRingSink === null) {
-			const seedParts = [];
-			if (typeof this.config.deviceId === "number") seedParts.push(String(this.config.deviceId));
-			if (typeof this.config.tag === "string" && this.config.tag.length > 0) seedParts.push(this.config.tag);
-			const seed = seedParts.length > 0 ? seedParts.join(":") : "anon";
-			this.frameRingSink = new DecoderFrameRingSink({
-				seed,
-				logger: this.logger,
-				nodeId: this.nodeId
-			});
-		}
-		return this.frameRingSink;
-	}
-	spawnFfmpeg() {
-		if (this.destroyed) return;
-		this.spawnAttempted = true;
-		this.clearPullRedial();
-		this.killFfmpeg();
-		this.abortOpenSlot();
-		this.splitter = null;
-		this.pendingStdout = [];
-		this.stderrAccum = "";
-		this.outWidth = 0;
-		this.outHeight = 0;
-		this.frameSize = 0;
-		this.activeGpuScaleFilter = this.gpuScaleEnabled ? resolveGpuScaleFilter(this.hwaccel, this.availableGpuScaleFilters) : null;
-		const args = buildFfmpegDecodeArgs({
-			codec: this.config.codec,
-			scale: this.config.scale,
-			outputFormat: this.config.outputFormat
-		}, {
-			hwaccel: this.hwaccel,
-			renderDevice: this.renderDevice,
-			gpuScaleFilter: this.activeGpuScaleFilter,
-			...this.pullUrl !== null ? { inputUrl: this.pullUrl } : {}
-		});
-		let child;
-		try {
-			child = spawn(this.ffmpegPath, args);
-		} catch (err) {
-			this.logger.error("ffmpeg decoder: spawn threw", { meta: { error: errMsg(err) } });
-			return;
-		}
-		this.process = child;
-		this.spawnedAtMs = Date.now();
-		child.stdin?.on("error", () => {});
-		this.replayGopBuffer(child);
-		child.stdout?.on("data", (chunk) => {
-			if (child === this.process) this.handleStdout(chunk);
-		});
-		child.stderr?.on("data", (data) => {
-			if (child === this.process) this.handleStderr(data);
-		});
-		child.on("error", (err) => {
-			if (child !== this.process) return;
-			this.logger.error("ffmpeg decoder: process error", { meta: { error: err.message } });
-		});
-		child.on("exit", (code, signal) => {
-			if (child === this.process) this.handleExit(code, signal);
-		});
-		this.logger.info("ffmpeg decoder: spawned", { meta: {
-			hwaccel: this.hwaccel,
-			gpuScale: this.activeGpuScaleFilter ?? "cpu",
-			codec: this.config.codec,
-			format: this.frameFormat,
-			sink: this.frameSink
-		} });
-	}
-	killFfmpeg() {
-		const child = this.process;
-		if (!child) return;
-		this.process = null;
-		child.stdout?.removeAllListeners("data");
-		child.stderr?.removeAllListeners("data");
-		child.removeAllListeners("exit");
-		try {
-			child.stdin?.end();
-		} catch {}
-		try {
-			child.kill("SIGTERM");
-		} catch {}
-		const pid = child.pid;
-		setTimeout(() => {
-			if (pid !== void 0 && child.exitCode === null && child.signalCode === null) try {
-				child.kill("SIGKILL");
-			} catch {}
-		}, 500).unref?.();
-	}
-	/** The decode path for the current attempt — `hwaccelChain[index]`, or `null`
-	*  (software) once the chain is exhausted. */
-	currentHwAccel() {
-		return this.hwaccelChain[this.hwaccelIndex] ?? null;
-	}
-	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 (this.activeGpuScaleFilter !== null) {
-				const brokenFilter = this.activeGpuScaleFilter;
-				this.gpuScaleEnabled = false;
-				this.onGpuScaleUnsupported?.(brokenFilter);
-				this.logger.warn("ffmpeg decoder: GPU-scale child exited early with no frames — retrying same backend with CPU scale", { meta: {
-					hwaccel: this.hwaccel,
-					gpuScaleFilter: brokenFilter,
-					code,
-					signal
-				} });
-				this.process = null;
-				this.spawnFfmpeg();
-				return;
-			}
-			const failed = this.hwaccel;
-			this.hwaccelIndex += 1;
-			this.hwaccel = this.currentHwAccel();
-			this.gpuScaleEnabled = true;
-			const next = 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,
-				code,
-				signal
-			} });
-			this.process = null;
-			this.spawnFfmpeg();
-			return;
-		}
-		this.process = null;
-		this.logger.warn("ffmpeg decoder: child exited", { meta: {
-			code,
-			signal,
-			outputFrames: this.outputFrames
-		} });
-		if (this.pullUrl !== null) {
-			this.clearPullRedial();
-			const timer = setTimeout(() => {
-				this.pullRedialTimer = null;
-				this.spawnFfmpeg();
-			}, PULL_REDIAL_DELAY_MS);
-			timer.unref?.();
-			this.pullRedialTimer = timer;
-			this.logger.info("ffmpeg decoder: pull-mode child exited — re-dial scheduled", { meta: {
-				code,
-				signal,
-				redialInMs: PULL_REDIAL_DELAY_MS
-			} });
-		}
-	}
-	/** Cancel a pending pull-mode re-dial, if armed. */
-	clearPullRedial() {
-		if (this.pullRedialTimer !== null) {
-			clearTimeout(this.pullRedialTimer);
-			this.pullRedialTimer = null;
-		}
-	}
-	handleStderr(data) {
-		const text = data.toString();
-		if (this.frameSize === 0) {
-			this.stderrAccum = (this.stderrAccum + text).slice(-16384);
-			this.tryLearnGeometry();
-		}
-		const line = text.trim();
-		if (line) this.logger.debug("ffmpeg stderr", { meta: { line } });
-	}
-	/** Parse the muxer's Output block once to size the raw frames. */
-	tryLearnGeometry() {
-		const idx = this.stderrAccum.indexOf("Output #");
-		if (idx < 0) return;
-		const match = this.stderrAccum.slice(idx).match(/(\d{2,5})x(\d{2,5})/);
-		if (!match) return;
-		const width = Number(match[1]);
-		const height = Number(match[2]);
-		if (width <= 0 || height <= 0) return;
-		this.outWidth = width;
-		this.outHeight = height;
-		this.frameSize = width * height * this.channels;
-		this.logger.info("ffmpeg decoder: learned output geometry", { meta: {
-			width,
-			height,
-			channels: this.channels,
-			frameSize: this.frameSize
-		} });
-		this.splitter = new FrameStreamSplitter(this.frameSize, this.makeSlotController());
-		const pending = this.pendingStdout;
-		this.pendingStdout = [];
-		for (const chunk of pending) this.splitter.push(chunk);
-	}
-	handleStdout(chunk) {
-		if (this.splitter === null) {
-			this.pendingStdout.push(chunk);
-			return;
-		}
-		this.splitter.push(chunk);
-	}
-	/**
-	* The frame lifecycle the {@link FrameStreamSplitter} drives. `startFrame`
-	* reserves a shm slot (zero-copy: the splitter fills the slot view in place)
-	* or, for the callback sink, allocates one frame buffer; `finishFrame`
-	* publishes the filled frame; `dropFrame` accounts an FPS-skipped one.
-	*/
-	makeSlotController() {
-		return {
-			startFrame: () => {
-				if (!this.frameDropper.shouldKeep()) return null;
-				if (this.frameSink === "shm") {
-					const reserved = this.ensureFrameRingSink().beginFrame(this.outWidth, this.outHeight, this.frameFormat);
-					if (reserved === null) return null;
-					this.openSlot = reserved.slot;
-					return reserved.buffer;
-				}
-				return Buffer.allocUnsafe(this.frameSize);
-			},
-			finishFrame: (target) => {
-				this.outputFrames++;
-				if (this.frameSink === "shm") {
-					const slot = this.openSlot;
-					this.openSlot = null;
-					const sink = this.frameRingSink;
-					if (slot === null || sink === null) return;
-					const handle = sink.commitFrame(slot, {
-						width: this.outWidth,
-						height: this.outHeight,
-						format: this.frameFormat,
-						pts: performance.now(),
-						byteLength: this.frameSize
-					});
-					if (handle === null) return;
-					const delivered = {
-						handle,
-						timestamp: Date.now()
-					};
-					for (const cb of this.handleCallbacks) cb(delivered);
-					return;
-				}
-				const frame = {
-					data: target,
-					width: this.outWidth,
-					height: this.outHeight,
-					format: this.frameFormat,
-					timestamp: Date.now()
-				};
-				for (const cb of this.frameCallbacks) cb(frame);
-			},
-			dropFrame: () => {
-				this.droppedFrames++;
-			}
-		};
-	}
-	/** Abandon a shm slot the splitter left open (respawn / teardown mid-frame),
-	*  so a half-filled slot is never published. */
-	abortOpenSlot() {
-		const slot = this.openSlot;
-		if (slot === null) return;
-		this.openSlot = null;
-		this.frameRingSink?.abortFrame(slot);
-	}
-	pushPacket(packet) {
-		if (this.destroyed) return;
-		if (this.pullUrl !== null) return;
-		this.recordGop(packet);
-		this.inputPackets++;
-		if (this.process === null && !this.spawnAttempted) {
-			this.spawnFfmpeg();
-			return;
-		}
-		const stdin = this.process?.stdin;
-		if (!stdin) return;
-		try {
-			stdin.write(packet.data);
-		} catch {}
-	}
-	/**
-	* Accumulate the current GOP for the keyframe-first re-spawn replay. Reset on
-	* each keyframe; P-frames before the first keyframe are ignored (useless to
-	* prime a decoder). A pathological long/no-keyframe GOP is capped to the
-	* keyframe alone (enough to re-prime SPS/PPS).
-	*/
-	recordGop(packet) {
-		if (packet.keyframe) {
-			this.gopBuffer = [packet.data];
-			this.gopBufferBytes = packet.data.length;
-			return;
-		}
-		if (this.gopBuffer.length === 0) return;
-		this.gopBuffer.push(packet.data);
-		this.gopBufferBytes += packet.data.length;
-		if (this.gopBufferBytes > MAX_GOP_BUFFER_BYTES) {
-			const keyframe = this.gopBuffer[0];
-			this.gopBuffer = [keyframe];
-			this.gopBufferBytes = keyframe.length;
-		}
-	}
-	/** Replay the buffered GOP (keyframe-first) into a freshly-spawned push child. */
-	replayGopBuffer(child) {
-		if (this.pullUrl !== null || this.gopBuffer.length === 0) return;
-		const stdin = child.stdin;
-		if (!stdin) return;
-		for (const buf of this.gopBuffer) try {
-			stdin.write(buf);
-		} catch {
-			return;
-		}
-	}
-	onFrame(callback) {
-		this.frameCallbacks.add(callback);
-		return () => {
-			this.frameCallbacks.delete(callback);
-		};
-	}
-	/** Subscribe to shared-memory frame handles — fires only in `'shm'` mode. */
-	onFrameHandle(callback) {
-		this.handleCallbacks.add(callback);
-		return () => {
-			this.handleCallbacks.delete(callback);
-		};
-	}
-	updateConfig(update) {
-		const needsRestart = update.scale !== void 0 && update.scale !== this.config.scale || update.outputFormat !== void 0 && update.outputFormat !== this.config.outputFormat || update.codec !== void 0 && update.codec !== this.config.codec;
-		this.config = {
-			...this.config,
-			...update
-		};
-		if (update.maxFps !== void 0) this.frameDropper.setMaxFps(update.maxFps);
-		if (needsRestart && this.spawnAttempted) this.spawnFfmpeg();
-	}
-	async destroy() {
-		if (this.destroyed) return;
-		this.destroyed = true;
-		this.clearPullRedial();
-		this.killFfmpeg();
-		this.abortOpenSlot();
-		this.splitter = null;
-		this.frameRingSink?.destroy();
-		this.frameRingSink = null;
-		this.frameCallbacks.clear();
-		this.handleCallbacks.clear();
-	}
-	getStats() {
-		const uptimeSec = Math.max((Date.now() - this.startTime) / 1e3, 1);
-		return {
-			inputFps: this.inputPackets / uptimeSec,
-			outputFps: this.outputFrames / uptimeSec,
-			avgDecodeTimeMs: 0,
-			droppedFrames: this.droppedFrames
-		};
-	}
-};
-//#endregion
-//#region src/decoder-ffmpeg/ffmpeg-filter-probe.ts
-/**
-* One-shot probe of the GPU scale filters an ffmpeg build offers.
-*
-* The decoder runs the downscale on the GPU (`scale_vaapi` / `scale_qsv` /
-* `scale_vt`) instead of downloading the full-resolution frame and scaling it on
-* the CPU — a large saving on VA-API. Whether a given build even compiled those
-* filters in is build-specific, so the addon probes `ffmpeg -filters` ONCE at
-* init and passes the result into every session. The parse
-* ({@link parseAvailableGpuScaleFilters}) is a pure function unit-tested in
-* `ffmpeg-args.spec.ts`; only the spawn lives here.
-*/
-/** How long to wait for `ffmpeg -filters` before giving up (→ empty set). */
-var PROBE_TIMEOUT_MS = 5e3;
-/**
-* Run `<ffmpegPath> -hide_banner -filters` and return the {@link GpuScaleFilter}s
-* the build lists. Never throws — a missing / slow / failing binary resolves to
-* an empty set, which makes every session fall back to the CPU-scale chain.
-*/
-function probeGpuScaleFilters(ffmpegPath, logger) {
-	return new Promise((resolve) => {
-		let stdout = "";
-		let settled = false;
-		const done = (set) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			resolve(set);
-		};
-		let child;
-		try {
-			child = spawn(ffmpegPath, ["-hide_banner", "-filters"]);
-		} catch (err) {
-			logger.warn("decoder-ffmpeg: GPU-scale filter probe spawn failed — CPU scale", { meta: { error: errMsg(err) } });
-			done(/* @__PURE__ */ new Set());
-			return;
-		}
-		const timer = setTimeout(() => {
-			try {
-				child.kill("SIGKILL");
-			} catch {}
-			logger.warn("decoder-ffmpeg: GPU-scale filter probe timed out — CPU scale");
-			done(/* @__PURE__ */ new Set());
-		}, PROBE_TIMEOUT_MS);
-		timer.unref?.();
-		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
-		});
-		child.on("error", (err) => {
-			logger.warn("decoder-ffmpeg: GPU-scale filter probe errored — CPU scale", { meta: { error: err.message } });
-			done(/* @__PURE__ */ new Set());
-		});
-		child.on("exit", () => {
-			done(parseAvailableGpuScaleFilters(stdout));
-		});
-	});
-}
-//#endregion
-//#region src/decoder-ffmpeg/addon/index.ts
-var FRAME_BUFFER_CAPACITY = 32;
-var DEFAULT_DECODER_FFMPEG_ADDON_CONFIG = {
-	...DEFAULT_DECODER_HWACCEL_CONFIG,
-	backend: DEFAULT_DECODER_BACKEND,
-	binaryPath: ""
-};
-/** The two selectable decoder backends, in default-first order. */
-var DECODER_BACKEND_OPTIONS = [{
-	value: "nodeav",
-	label: "node-av (in-process FFmpeg bindings — default)"
-}, {
-	value: "ffmpeg",
-	label: "ffmpeg (subprocess — crash-isolated fallback)"
-}];
-var DecoderFfmpegAddon = class extends BaseAddon {
-	sessions = /* @__PURE__ */ new Map();
-	frameBuffers = /* @__PURE__ */ new Map();
-	handleBuffers = /* @__PURE__ */ new Map();
-	unsubscribers = /* @__PURE__ */ new Map();
-	sessionMeta = /* @__PURE__ */ new Map();
-	frameReaders = null;
-	getFrameHits = 0;
-	getFrameMisses = 0;
-	/**
-	* The ffmpeg binary every session spawns — resolved once at init from the
-	* cluster `ffmpeg` config section (`binaryPath`), defaulting to PATH
-	* `ffmpeg`. MUST be the same binary the broker / recorder / probe use so the
-	* decode-accel probe reports for the right build.
-	*/
-	ffmpegPath = "ffmpeg";
-	/**
-	* GPU scale filters the resolved ffmpeg build offers (`scale_vaapi` /
-	* `scale_qsv` / `scale_vt`), probed once at init. A session running one of
-	* these downscales on the GPU instead of the CPU (a large VA-API saving).
-	*/
-	probedGpuScaleFilters = /* @__PURE__ */ new Set();
-	/**
-	* GPU scalers the build LISTS but that proved non-functional at runtime (a
-	* session's GPU-scale child died with no frames and self-healed to CPU scale).
-	* Excluded from later sessions so the failed spawn happens at most once per
-	* process — e.g. a videotoolbox build whose decode returns software frames.
-	*/
-	unsupportedGpuScaleFilters = /* @__PURE__ */ new Set();
-	constructor() {
-		super(DEFAULT_DECODER_FFMPEG_ADDON_CONFIG);
-	}
-	globalSettingsSchema() {
-		return this.schema({ sections: [{
-			id: "backend",
-			title: "Decoder backend",
-			tab: "decoder",
-			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: "backend",
-				label: "Backend",
-				options: [...DECODER_BACKEND_OPTIONS],
-				default: 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: [...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() {
-		if (!this.config.probedBestHwaccel) this.reprobeHwaccel().catch((err) => {
-			this.ctx.logger.warn("ffmpeg: auto-reprobe hwaccel failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		});
-		let backend;
-		try {
-			backend = resolveOwnDecoderBackend(await this.resolveGlobalStore(this.resolveLocalNodeId()));
-		} catch (err) {
-			this.ctx.logger.warn("decoder-ffmpeg: own-store backend read failed — using default", { meta: {
-				default: DEFAULT_DECODER_BACKEND,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-			backend = DEFAULT_DECODER_BACKEND;
-		}
-		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 [];
-		}
-		this.ctx.logger.info("ffmpeg decoder addon initialized", { meta: { selectedBackend: backend } });
-		this.frameReaders = new FrameRingReaderCache(this.ctx.logger);
-		this.ffmpegPath = await this.resolveFfmpegBinaryPath();
-		this.probedGpuScaleFilters = await probeGpuScaleFilters(this.ffmpegPath, this.ctx.logger);
-		this.ctx.logger.info("decoder-ffmpeg: probed GPU scale filters", { meta: {
-			filters: [...this.probedGpuScaleFilters],
-			ffmpeg: this.ffmpegPath
-		} });
-		return [{
-			capability: decoderCapability,
-			provider: this
-		}];
-	}
-	/**
-	* Resolve the ffmpeg binary the sessions spawn.
-	*
-	* Precedence:
-	* 1. An explicit operator override in the cluster `ffmpeg` config section
-	*    (`binaryPath`) — wins when set, so a hand-picked build can be forced.
-	* 2. Otherwise `ctx.deps.ensureFfmpeg()` — provisions a portable static
-	*    ffmpeg into the node's deps dir when the system has none and returns its
-	*    absolute path. This GUARANTEES ffmpeg on every node (hub, agent, Mac),
-	*    so there is no missing-ffmpeg case and no node-av fallback.
-	*
-	* `ensureFfmpeg()` is single-flighted, so we resolve once at init and reuse
-	* the path for every session. If it throws (e.g. a download failure) we log a
-	* loud ERROR and fall back to PATH `ffmpeg`; the addon still registers the
-	* decoder cap and a later session spawn re-runs the ensure.
-	*/
-	async resolveFfmpegBinaryPath() {
-		const override = this.config.binaryPath;
-		if (typeof override === "string" && override.trim().length > 0) return override;
-		try {
-			return await this.ctx.deps.ensureFfmpeg();
-		} catch (err) {
-			this.ctx.logger.error("decoder-ffmpeg: ensureFfmpeg() failed to provision ffmpeg — falling back to PATH \"ffmpeg\"; a later session will retry", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			return "ffmpeg";
-		}
-	}
-	/**
-	* Resolve the ORDERED decode-hwaccel chain for a new session — NEVER
-	* hardcoded. The session tries the chain best-first and only falls to
-	* software once every hardware option is exhausted.
-	*
-	* - `'none'` → `[]` (pure software).
-	* - explicit backend → `[<backend>]` (forced; the session still falls to
-	*   software if that one child fails).
-	* - `'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 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 [];
-		}
-	}
-	async reprobeHwaccel() {
-		const resolver = this.ctx.kernel.hwaccel;
-		if (!resolver) {
-			this.ctx.logger.warn("reprobeHwaccel: no kernel hwaccel resolver — returning none");
-			await this.updateGlobalSettings({ probedBestHwaccel: "none" });
-			return { backend: "none" };
-		}
-		try {
-			const res = await resolver.resolve();
-			const backend = rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
-			await this.updateGlobalSettings({ probedBestHwaccel: backend });
-			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
-				backend,
-				rationale: res.rationale,
-				preferred: res.preferred
-			} });
-			return { backend };
-		} catch (err) {
-			this.ctx.logger.warn("reprobeHwaccel failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			await this.updateGlobalSettings({ probedBestHwaccel: "none" });
-			return { backend: "none" };
-		}
-	}
-	async supportsCodec(input) {
-		return [
-			"h264",
-			"h265",
-			"hevc"
-		].includes(input.codec.toLowerCase());
-	}
-	async getInfo() {
-		return {
-			id: "decoder-ffmpeg",
-			name: "Decoder (ffmpeg)",
-			isPullMode: true,
-			priority: 20
-		};
-	}
-	/**
-	* The cluster node id of this decoder — stamped into session-owned
-	* `FrameHandle`s so a downstream consumer routes `getFrame` to the node that
-	* holds the shm ring. Mirrors `decoder-nodeav`.
-	*/
-	resolveLocalNodeId() {
-		const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
-		return raw.includes("/") ? raw.split("/")[0] : raw;
-	}
-	async createSession(config) {
-		const sessionId = randomUUID();
-		const { frameSink } = config;
-		const nodeId = this.resolveLocalNodeId();
-		const hwaccelChain = await this.resolveDecodeHwaccelChain();
-		const availableGpuScaleFilters = new Set([...this.probedGpuScaleFilters].filter((f) => !this.unsupportedGpuScaleFilters.has(f)));
-		const session = new FfmpegDecoderSession(config, this.ctx.logger, {
-			hwaccelChain,
-			ffmpegPath: this.ffmpegPath,
-			frameSink,
-			nodeId,
-			availableGpuScaleFilters,
-			onGpuScaleUnsupported: (filter) => {
-				if (this.unsupportedGpuScaleFilters.has(filter)) return;
-				this.unsupportedGpuScaleFilters.add(filter);
-				this.ctx.logger.warn("decoder-ffmpeg: GPU scaler non-functional on this build — future sessions use CPU scale", { meta: { filter } });
-			}
-		});
-		const unsub = frameSink === "shm" ? this.wireShmSink(sessionId, session) : this.wireCallbackSink(sessionId, session);
-		this.sessions.set(sessionId, session);
-		this.unsubscribers.set(sessionId, unsub);
-		this.sessionMeta.set(sessionId, {
-			codec: config.codec,
-			outputFormat: config.outputFormat,
-			createdAtMs: Date.now()
-		});
-		this.ctx.logger.info("ffmpeg: created session", { meta: {
-			sessionId,
-			codec: config.codec,
-			hwaccelChain,
-			frameSink,
-			nodeId
-		} });
-		return {
-			sessionId,
-			nodeId
-		};
-	}
-	wireCallbackSink(sessionId, session) {
-		const ringBuffer = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
-		this.frameBuffers.set(sessionId, ringBuffer);
-		return session.onFrame((frame) => {
-			const { format } = frame;
-			if (format !== "jpeg" && format !== "rgb" && format !== "bgr" && format !== "yuv420" && format !== "gray") return;
-			const arrayBuf = new ArrayBuffer(frame.data.byteLength);
-			new Uint8Array(arrayBuf).set(frame.data);
-			const capFrame = {
-				data: new Uint8Array(arrayBuf),
-				width: frame.width,
-				height: frame.height,
-				format,
-				timestamp: frame.timestamp
-			};
-			ringBuffer.push(capFrame);
-		});
-	}
-	wireShmSink(sessionId, session) {
-		const handleRing = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
-		this.handleBuffers.set(sessionId, handleRing);
-		return session.onFrameHandle((frame) => {
-			handleRing.push(frame.handle);
-		});
-	}
-	async destroySession(input) {
-		const { sessionId } = input;
-		const session = this.sessions.get(sessionId);
-		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);
-		this.handleBuffers.delete(sessionId);
-		this.unsubscribers.delete(sessionId);
-		this.sessionMeta.delete(sessionId);
-		this.ctx.logger.info("ffmpeg: destroyed session", { meta: { sessionId } });
-	}
-	async listActiveSessions() {
-		const out = [];
-		for (const [sessionId, meta] of this.sessionMeta) out.push({
-			sessionId,
-			codec: meta.codec,
-			outputFormat: meta.outputFormat,
-			createdAtMs: meta.createdAtMs
-		});
-		return out;
-	}
-	async pushPacket(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
-		const rawData = input.packet.data;
-		const data = Buffer.isBuffer(rawData) ? rawData : rawData instanceof Uint8Array ? Buffer.from(rawData.buffer, rawData.byteOffset, rawData.byteLength) : Buffer.from(rawData);
-		session.pushPacket({
-			...input.packet,
-			data
-		});
-	}
-	async openStream(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
-		await session.openStream(input.url);
-	}
-	async pullFrames(input) {
-		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) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
-		session.updateConfig(input.config);
-	}
-	async getStats(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
-		return session.getStats();
-	}
-	async getFrame(input) {
-		const frame = this.frameReaders?.read(input.handle) ?? null;
-		if (!frame) {
-			this.getFrameMisses += 1;
-			return null;
-		}
-		this.getFrameHits += 1;
-		const arrayBuf = new ArrayBuffer(frame.data.byteLength);
-		new Uint8Array(arrayBuf).set(frame.data);
-		return {
-			data: new Uint8Array(arrayBuf),
-			width: frame.width,
-			height: frame.height,
-			format: frame.format,
-			timestamp: frame.timestamp
-		};
-	}
-	async getShmStats(input) {
-		const stats = this.sessions.get(input.sessionId)?.frameRingSinkOrNull?.getShmStats() ?? null;
-		if (!stats) return null;
-		return {
-			sessionId: input.sessionId,
-			...stats,
-			budgetMb: RING_BUDGET_MB,
-			getFrameHits: this.getFrameHits,
-			getFrameMisses: this.getFrameMisses
-		};
-	}
-	async onShutdown() {
-		this.ctx.logger.info("ffmpeg decoder addon shutdown — destroying all sessions");
-		const destroyPromises = [];
-		for (const [sessionId, session] of this.sessions) {
-			const unsub = this.unsubscribers.get(sessionId);
-			if (unsub) unsub();
-			destroyPromises.push(session.destroy());
-		}
-		await Promise.all(destroyPromises);
-		this.sessions.clear();
-		this.frameBuffers.clear();
-		this.handleBuffers.clear();
-		this.unsubscribers.clear();
-		this.sessionMeta.clear();
-		this.frameReaders?.close();
-		this.frameReaders = null;
-	}
-};
-//#endregion
-export { DECODE_HWACCEL_RANK, DEFAULT_VAAPI_RENDER_DEVICE, DecoderFfmpegAddon, DecoderFfmpegAddon as default, FfmpegDecoderSession, buildFfmpegDecodeArgs, channelsForPixel, codecToInputFormat, computeOutputGeometry, maxDecodeWidth, parseFfmpegOutputDims, pickDecodeHwAccel, rankDecodeHwAccels, rawPixelForFormat };