@camstack/addon-pipeline 1.1.17 → 1.1.19

package/dist/decoder-ffmpeg/index.mjs

@@ -0,0 +1,1162 @@
+import { B as BaseAddon, b as decoderCapability, f as RingBuffer, s as DEFAULT_DECODER_HWACCEL_CONFIG, u as HWACCEL_OPTIONS, z as errMsg } from "../dist-7Yx2dmuV.mjs";
+import { n as logBannerArgs, r as FrameDropper } from "../ffmpeg-args-common-c3p-nWtU.mjs";
+import { FrameRingReaderCache, FrameRingWriter, MIN_RING_SLOTS, computeSegmentSize, computeSlotByteLength, createSegment, deriveSlotCount } from "@camstack/shm-ring";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+//#region src/decoder-nodeav/frame-ring-sink.ts
+/**
+* `DecoderFrameRingSink` — the decoder's shared-memory write side (Phase 5 / D9).
+*
+* When a decoder session is configured with `frameSink: 'shm'`, the decoder
+* **owns** the shared-memory ring segment for that stream: it creates the
+* segment on the first decoded frame (when the output geometry is known),
+* writes every subsequent decoded frame into the ring via a `FrameRingWriter`,
+* and closes + unlinks the segment when the session is destroyed.
+*
+* What leaves the decoder is no longer the pixel `Buffer` — it is a tiny,
+* serialisable `FrameHandle` (`FrameRingWriter.writeFrame`'s return value).
+* Same-host consumers (motion, detection, the WebRTC encoder) open the same
+* segment with a `FrameRingReader` and read the pixels zero-copy.
+*
+* ## Lazy segment creation
+*
+* The segment cannot be sized until the first frame: `slotByteLength` is
+* `width × height × bytesPerPixel`, and the output dimensions are only known
+* once the scaler has produced its first `dstFrame`. So `writeFrame` is a
+* no-op-until-armed: the first call sizes + creates the segment, every later
+* call writes into it.
+*
+* ## Resolution-change decision
+*
+* A live camera stream can change resolution mid-stream (the decoder's scaler
+* is rebuilt on a config toggle, or the source renegotiates). The slot is
+* sized for the **first** frame's geometry. A later frame that no longer fits
+* the slot triggers a **segment re-create**: the old segment is closed +
+* unlinked and a fresh, larger segment is created under a new generation-tagged
+* name. This is simpler and leak-free versus over-allocating slots for a
+* worst-case 4K frame on every stream; resolution changes on a live camera are
+* rare, and a brief gap while consumers re-open the segment is acceptable
+* (latest-wins — a missed frame is correct behaviour).
+*/
+/**
+* Per-ring shared-memory budget (MB) — the slot count is derived per-resolution
+* from this budget via {@link deriveSlotCount}, so a 360p stream gets many
+* slots and a 4K stream a few, both inside the same memory footprint.
+*
+* Read ONCE at module load from `CAMSTACK_SHM_RING_BUDGET_MB`; a non-finite or
+* non-positive value falls back to the 16 MB default.
+*
+* The default is deliberately small (16 MB) so many concurrent per-camera rings
+* fit inside a bounded `/dev/shm`. The decoder output is capped at 640px wide, so
+* a slot is ≤ ~920 KB and 16 MB still yields ~17–70 latest-wins slots. A ring
+* segment larger than the container's `/dev/shm` tmpfs backing (Docker default is
+* only 64 MB) faults an **uncatchable SIGBUS** on write past `st_size` — the old
+* 128 MB default overflowed a 64 MB `/dev/shm` and crashed the decoder on 8MP
+* streams. Pair this with a `--shm-size` that scales with concurrent-decode load.
+*/
+var RING_BUDGET_MB = (() => {
+	const raw = Number(process.env["CAMSTACK_SHM_RING_BUDGET_MB"]);
+	return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 16;
+})();
+/** {@link RING_BUDGET_MB} in bytes — the budget passed to `deriveSlotCount`. */
+var RING_BUDGET_BYTES = RING_BUDGET_MB * 1024 * 1024;
+/** A unique, stable shared-memory segment name for a decoder stream.
+*
+* macOS POSIX shm names are capped at ~31 characters (`PSHMNAMLEN`). A
+* `camstack.frames.<deviceId>.<streamId>` scheme overflows that for realistic
+* ids, so the sink uses a short, collision-resistant scheme instead:
+* `csf.<base36 hash>.<gen>`. The hash folds the device id, the session tag
+* and a per-process random salt; the generation suffix makes a re-created
+* segment (resolution change) a distinct name so a stale consumer mapping is
+* never silently reused.
+*/
+function makeSegmentName(seed, generation) {
+	let hash = 5381;
+	for (let i = 0; i < seed.length; i += 1) hash = (hash << 5) + hash + seed.charCodeAt(i) | 0;
+	return `csf.${(hash >>> 0).toString(36)}.${generation}`;
+}
+/**
+* The decoder-side owner of one stream's shared-memory frame ring.
+*
+* Not constructed until a session actually uses the shm sink; the segment
+* itself is created lazily on the first `writeFrame`.
+*/
+var DecoderFrameRingSink = class {
+	seed;
+	logger;
+	nodeId;
+	segment = null;
+	writer = null;
+	segmentName = null;
+	slotByteLength = 0;
+	generation = 0;
+	destroyed = false;
+	/** Frames committed into the ring across this sink's lifetime (all generations). */
+	framesWritten = 0;
+	constructor(options) {
+		const salt = Math.random().toString(36).slice(2, 8);
+		this.seed = `${options.seed}.${salt}`;
+		this.logger = options.logger;
+		this.nodeId = options.nodeId;
+	}
+	/** Whether a segment has been created (i.e. at least one frame written). */
+	get isArmed() {
+		return this.writer !== null;
+	}
+	/** The current segment name, or `null` before the first frame. */
+	get currentSegmentName() {
+		return this.segmentName;
+	}
+	/**
+	* Write one decoded frame into the ring and return its `FrameHandle`.
+	*
+	* On the first call (or after a geometry change that overflows the current
+	* slot) the segment is created / re-created sized for this frame. Returns
+	* `null` only when the sink has been destroyed.
+	*
+	* This is the copy-in convenience form (it copies `pixels` into the slot).
+	* The decoder's hot path uses the zero-copy {@link beginFrame} /
+	* {@link commitFrame} scatter-write pair instead — the scaler produces its
+	* packed output directly into the slot, eliminating the write-side memcpy.
+	*/
+	writeFrame(pixels, meta) {
+		if (this.destroyed) return null;
+		if (this.writer === null || computeSlotByteLength(meta.width, meta.height, meta.format) > this.slotByteLength) this.recreateSegment(computeSlotByteLength(meta.width, meta.height, meta.format));
+		const writer = this.writer;
+		if (writer === null) return null;
+		const handle = writer.writeFrame(pixels, meta);
+		this.framesWritten += 1;
+		return handle;
+	}
+	/**
+	* Reserve a ring slot for a frame of the given geometry — the **zero-copy**
+	* scatter-write entry point (Phase 5 / D9 Task 7c).
+	*
+	* The segment is created / re-created here if this is the first frame or the
+	* geometry overflows the current slot capacity, so the slot is correctly
+	* sized before the caller fills it. The returned `buffer` is a writable view
+	* **directly over the mapped segment** — the node-av scaler scatters its
+	* packed output straight into it, with no intermediate copy. The caller MUST
+	* call {@link commitFrame} with the returned `slot` once the slot is filled.
+	*
+	* Returns `null` when the sink is destroyed or the segment cannot be created.
+	*/
+	beginFrame(width, height, format) {
+		if (this.destroyed) return null;
+		const requiredSlotBytes = computeSlotByteLength(width, height, format);
+		if (this.writer === null || requiredSlotBytes > this.slotByteLength) this.recreateSegment(requiredSlotBytes);
+		const writer = this.writer;
+		if (writer === null) return null;
+		const { slot, buffer } = writer.beginFrame();
+		return {
+			slot,
+			buffer
+		};
+	}
+	/**
+	* Publish the frame whose slot was reserved by {@link beginFrame} and filled
+	* in place by the caller. `slot` MUST be the value from the matching
+	* `beginFrame`. Returns the published `FrameHandle`, or `null` if the sink
+	* was destroyed (or the segment lost) between begin and commit.
+	*/
+	commitFrame(slot, meta) {
+		if (this.destroyed) return null;
+		const writer = this.writer;
+		if (writer === null) return null;
+		const handle = writer.commitFrame(slot, meta);
+		this.framesWritten += 1;
+		return handle;
+	}
+	/**
+	* Current shm ring usage — `null` until the first frame arms the segment.
+	* Surfaced through `decoder.getShmStats` so a downstream consumer can
+	* observe ring pressure (slot depth, byte budget, frames written).
+	*/
+	getShmStats() {
+		if (this.writer === null) return null;
+		return {
+			slotCount: this.writer.slotCount,
+			slotByteLength: this.slotByteLength,
+			segmentBytes: computeSegmentSize(this.writer.slotCount, this.slotByteLength),
+			framesWritten: this.framesWritten
+		};
+	}
+	/**
+	* Abandon a slot reserved by {@link beginFrame} **without publishing it** —
+	* the degenerate-path counterpart of {@link commitFrame}.
+	*
+	* A caller that reserved a slot but then could not produce valid pixels (no
+	* decoded source planes, or the scaler threw) MUST call this instead of
+	* `commitFrame`: it closes the open seqlock without advancing `writeIndex`,
+	* so no reader ever sees the slot's uninitialised bytes as a real frame, and
+	* no `FrameHandle` is handed downstream. `slot` MUST be the value from the
+	* matching `beginFrame`. A no-op if the sink was destroyed (or the segment
+	* lost) between begin and abort.
+	*/
+	abortFrame(slot) {
+		if (this.destroyed) return;
+		const writer = this.writer;
+		if (writer === null) return;
+		writer.abortFrame(slot);
+	}
+	/** Close + unlink the segment. Idempotent. */
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.releaseSegment();
+	}
+	/**
+	* Create a fresh segment sized for at least `slotByteLength` bytes per slot,
+	* replacing any prior one. A re-create bumps the generation so the new
+	* segment has a distinct name — a consumer holding the old mapping is never
+	* silently handed a resized segment.
+	*/
+	recreateSegment(slotByteLength) {
+		this.releaseSegment();
+		this.generation += 1;
+		const name = makeSegmentName(this.seed, this.generation);
+		const slotCount = deriveSlotCount(RING_BUDGET_BYTES, slotByteLength);
+		if (slotCount === MIN_RING_SLOTS && MIN_RING_SLOTS * slotByteLength > RING_BUDGET_BYTES) this.logger.warn("decoder shm ring: budget too small for resolution — using MIN slots", { meta: {
+			slotByteLength,
+			budgetMb: RING_BUDGET_MB
+		} });
+		const totalBytes = computeSegmentSize(slotCount, slotByteLength);
+		try {
+			const segment = createSegment(name, totalBytes);
+			this.segment = segment;
+			this.segmentName = name;
+			this.slotByteLength = slotByteLength;
+			this.writer = new FrameRingWriter(segment.buffer, name, slotCount, slotByteLength, this.nodeId);
+			this.logger.info("decoder shm ring: segment created", { meta: {
+				segment: name,
+				slotCount,
+				slotByteLength,
+				totalBytes,
+				generation: this.generation
+			} });
+		} catch (err) {
+			this.segment = null;
+			this.writer = null;
+			this.segmentName = null;
+			this.slotByteLength = 0;
+			this.logger.error("decoder shm ring: segment create failed", { meta: {
+				segment: name,
+				slotByteLength,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+	/** Unmap + unlink the current segment, if any. */
+	releaseSegment() {
+		const segment = this.segment;
+		if (segment === null) return;
+		this.segment = null;
+		this.writer = null;
+		const name = this.segmentName;
+		this.segmentName = null;
+		try {
+			segment.close();
+			segment.unlink();
+			this.logger.info("decoder shm ring: segment released", { meta: { segment: name } });
+		} catch (err) {
+			this.logger.warn("decoder shm ring: segment release failed", { meta: {
+				segment: name,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+};
+//#endregion
+//#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";
+}
+/** 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) {
+	const scaleAndFormat = `scale=${outWidth !== void 0 && outWidth > 0 && outHeight !== void 0 && outHeight > 0 ? `${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); the output is raw
+*   video on `pipe:1`.
+*/
+function buildFfmpegDecodeArgs(config, options) {
+	const inputFormat = codecToInputFormat(config.codec);
+	const pixel = rawPixelForFormat(config.outputFormat);
+	const maxW = maxDecodeWidth(config.scale);
+	const vf = buildVideoFilter(options.hwaccel, pixel, options.outWidth, options.outHeight, maxW);
+	const { hwaccel } = options;
+	let hwaccelArgs;
+	if (isSoftwareHwAccel(hwaccel) || hwaccel === null) hwaccelArgs = [];
+	else if (needsHwDownload(hwaccel)) hwaccelArgs = [
+		"-hwaccel",
+		hwaccel,
+		"-hwaccel_device",
+		options.renderDevice ?? "/dev/dri/renderD128",
+		"-hwaccel_output_format",
+		hwaccel
+	];
+	else hwaccelArgs = ["-hwaccel", hwaccel];
+	return [
+		...logBannerArgs("info"),
+		"-nostats",
+		"-fflags",
+		"+nobuffer+flush_packets",
+		"-flags",
+		"low_delay",
+		"-probesize",
+		"1M",
+		"-analyzeduration",
+		"0",
+		...hwaccelArgs,
+		"-f",
+		inputFormat,
+		"-i",
+		"pipe:0",
+		"-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/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 [hwdownload,format=nv12,]scale=…,format=<rgb24|gray>`
+*   raw video → ffmpeg stdout (pipe:1) → fixed-size frame slices
+*   each slice → `DecoderFrameRingSink.writeFrame` → `FrameHandle` (shm mode)
+*                 or `DecodedFrame` via `onFrame` (callback mode)
+*
+* 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;
+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;
+	process = null;
+	spawnedAtMs = 0;
+	outputBuffer = Buffer.alloc(0);
+	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;
+	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.pixel = rawPixelForFormat(config.outputFormat);
+		this.channels = channelsForPixel(this.pixel);
+		this.frameFormat = this.pixel === "gray" ? "gray" : "rgb";
+		this.frameDropper = new FrameDropper(config.maxFps);
+		this.spawnFfmpeg();
+	}
+	/** Exposed so the owning addon can surface ring stats via `getShmStats`. */
+	get frameRingSinkOrNull() {
+		return this.frameRingSink;
+	}
+	get isPullMode() {
+		return false;
+	}
+	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.killFfmpeg();
+		this.outputBuffer = Buffer.alloc(0);
+		this.stderrAccum = "";
+		this.outWidth = 0;
+		this.outHeight = 0;
+		this.frameSize = 0;
+		const args = buildFfmpegDecodeArgs({
+			codec: this.config.codec,
+			scale: this.config.scale,
+			outputFormat: this.config.outputFormat
+		}, {
+			hwaccel: this.hwaccel,
+			renderDevice: this.renderDevice
+		});
+		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", () => {});
+		child.stdout?.on("data", (chunk) => this.handleStdout(chunk));
+		child.stderr?.on("data", (data) => this.handleStderr(data));
+		child.on("error", (err) => {
+			this.logger.error("ffmpeg decoder: process error", { meta: { error: err.message } });
+		});
+		child.on("exit", (code, signal) => this.handleExit(code, signal));
+		this.logger.info("ffmpeg decoder: spawned", { meta: {
+			hwaccel: this.hwaccel,
+			codec: this.config.codec,
+			format: this.frameFormat,
+			sink: this.frameSink
+		} });
+	}
+	killFfmpeg() {
+		const child = this.process;
+		if (!child) return;
+		this.process = null;
+		try {
+			child.stdin?.end();
+		} catch {}
+		try {
+			child.kill("SIGTERM");
+		} catch {}
+		const pid = child.pid;
+		setTimeout(() => {
+			if (pid !== void 0 && !child.killed) 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) {
+			const failed = this.hwaccel;
+			this.hwaccelIndex += 1;
+			this.hwaccel = this.currentHwAccel();
+			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
+		} });
+	}
+	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.drainFrames();
+	}
+	handleStdout(chunk) {
+		this.outputBuffer = this.outputBuffer.length === 0 ? chunk : Buffer.concat([this.outputBuffer, chunk]);
+		if (this.frameSize === 0) return;
+		this.drainFrames();
+	}
+	drainFrames() {
+		const size = this.frameSize;
+		if (size === 0) return;
+		let offset = 0;
+		while (this.outputBuffer.length - offset >= size) {
+			const slice = this.outputBuffer.subarray(offset, offset + size);
+			offset += size;
+			this.emitFrame(slice);
+		}
+		if (offset > 0) this.outputBuffer = Buffer.from(this.outputBuffer.subarray(offset));
+	}
+	emitFrame(slice) {
+		if (!this.frameDropper.shouldKeep()) {
+			this.droppedFrames++;
+			return;
+		}
+		const pixels = Buffer.from(slice);
+		this.outputFrames++;
+		if (this.frameSink === "shm") {
+			const handle = this.ensureFrameRingSink().writeFrame(pixels, {
+				width: this.outWidth,
+				height: this.outHeight,
+				format: this.frameFormat,
+				pts: performance.now(),
+				byteLength: pixels.byteLength
+			});
+			if (handle === null) {
+				this.droppedFrames++;
+				return;
+			}
+			const delivered = {
+				handle,
+				timestamp: Date.now()
+			};
+			for (const cb of this.handleCallbacks) cb(delivered);
+			return;
+		}
+		const frame = {
+			data: pixels,
+			width: this.outWidth,
+			height: this.outHeight,
+			format: this.frameFormat,
+			timestamp: Date.now()
+		};
+		for (const cb of this.frameCallbacks) cb(frame);
+	}
+	pushPacket(packet) {
+		if (this.destroyed) return;
+		const stdin = this.process?.stdin;
+		if (!stdin) return;
+		this.inputPackets++;
+		try {
+			stdin.write(packet.data);
+		} catch {}
+	}
+	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.spawnFfmpeg();
+	}
+	async destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.killFfmpeg();
+		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/addon/index.ts
+var FRAME_BUFFER_CAPACITY = 32;
+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";
+	constructor() {
+		super(DEFAULT_DECODER_HWACCEL_CONFIG);
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			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
+			}), 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"
+				}]
+			})]
+		}] });
+	}
+	async onInitialize() {
+		this.ctx.logger.info("ffmpeg decoder addon initialized");
+		this.frameReaders = new FrameRingReaderCache(this.ctx.logger);
+		this.ffmpegPath = await this.resolveFfmpegBinaryPath();
+		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) } });
+		});
+		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() {
+		try {
+			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
+			if (typeof bp === "string" && bp.trim().length > 0) return bp;
+		} catch {}
+		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'` → 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).
+	*/
+	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);
+		} 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.ctx.settings?.writeAddonStore({ probedBestHwaccel: "none" });
+			return { backend: "none" };
+		}
+		try {
+			const res = await resolver.resolve();
+			const backend = res.preferred[0] ?? "none";
+			await this.ctx.settings?.writeAddonStore({ 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.ctx.settings?.writeAddonStore({ 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: false,
+			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 session = new FfmpegDecoderSession(config, this.ctx.logger, {
+			hwaccelChain,
+			ffmpegPath: this.ffmpegPath,
+			frameSink,
+			nodeId
+		});
+		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 RingBuffer(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 RingBuffer(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();
+		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) {
+		if (!this.sessions.get(input.sessionId)) throw new Error(`decoder-ffmpeg: unknown sessionId ${input.sessionId}`);
+		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 [];
+		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 [];
+		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 };