@camstack/addon-pipeline 1.1.26 → 1.1.28

package/dist/decoder-ffmpeg/index.mjs

@@ -1,6 +1,7 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, p as RingBuffer, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-CgEP_0OL.mjs";
+import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, j as nodePin, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-C6_wgXqF.mjs";
+import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, o as DEFAULT_DECODER_BACKEND, t as DecoderFrameRingSink } from "../frame-ring-sink-Cs9vby6v.mjs";
 import { r as logBannerArgs, t as FrameDropper } from "../frame-dropper-CwkBTPGV.mjs";
-import { FrameRingReaderCache, FrameRingWriter, MIN_RING_SLOTS, computeSegmentSize, computeSlotByteLength, createSegment, deriveSlotCount } from "@camstack/shm-ring";
+import { FrameRingReaderCache } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 //#region src/decoder-ffmpeg/ffmpeg-args.ts
@@ -296,270 +297,6 @@ function rankDecodeHwAccels(preferred, supportedMethods) {
 	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
 }
 //#endregion
-//#region src/decoder-ffmpeg/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/frame-stream-splitter.ts
 var FrameStreamSplitter = class {
 	frameSize;
@@ -695,6 +432,14 @@ var FfmpegDecoderSession = class {
 	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
@@ -750,7 +495,6 @@ var FfmpegDecoderSession = class {
 		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() {
@@ -793,6 +537,7 @@ var FfmpegDecoderSession = class {
 	}
 	spawnFfmpeg() {
 		if (this.destroyed) return;
+		this.spawnAttempted = true;
 		this.clearPullRedial();
 		this.killFfmpeg();
 		this.abortOpenSlot();
@@ -823,12 +568,19 @@ var FfmpegDecoderSession = class {
 		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.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) => this.handleExit(code, signal));
+		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",
@@ -841,6 +593,9 @@ var FfmpegDecoderSession = class {
 		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 {}
@@ -1024,6 +779,7 @@ var FfmpegDecoderSession = class {
 	pushPacket(packet) {
 		if (this.destroyed) return;
 		if (this.pullUrl !== null) return;
+		if (this.process === null && !this.spawnAttempted) this.spawnFfmpeg();
 		const stdin = this.process?.stdin;
 		if (!stdin) return;
 		this.inputPackets++;
@@ -1051,7 +807,7 @@ var FfmpegDecoderSession = class {
 			...update
 		};
 		if (update.maxFps !== void 0) this.frameDropper.setMaxFps(update.maxFps);
-		if (needsRestart) this.spawnFfmpeg();
+		if (needsRestart && this.spawnAttempted) this.spawnFfmpeg();
 	}
 	async destroy() {
 		if (this.destroyed) return;
@@ -1136,6 +892,18 @@ function probeGpuScaleFilters(ffmpegPath, logger) {
 //#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
+};
+/** 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 BaseAddon {
 	sessions = /* @__PURE__ */ new Map();
 	frameBuffers = /* @__PURE__ */ new Map();
@@ -1166,10 +934,24 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 	*/
 	unsupportedGpuScaleFilters = /* @__PURE__ */ new Set();
 	constructor() {
-		super(DEFAULT_DECODER_HWACCEL_CONFIG);
+		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",
@@ -1188,6 +970,7 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 				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",
@@ -1197,7 +980,12 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 		}] });
 	}
 	async onInitialize() {
-		this.ctx.logger.info("ffmpeg decoder addon initialized");
+		const backend = await 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 [];
+		}
+		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);
@@ -1260,8 +1048,9 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 		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();
+			const pin = nodePin(this.resolveLocalNodeId());
+			const res = await this.ctx.api.platformProbe.resolveHwAccel.query({ prefer: null }, pin);
+			const supported = await this.ctx.api.platformProbe.getHardwareDecodeAccels.query(void 0, pin);
 			return rankDecodeHwAccels(res.preferred, supported.methods);
 		} catch (err) {
 			this.ctx.logger.warn("ffmpeg: decode-hwaccel probe failed — software decode", { meta: { error: err instanceof Error ? err.message : String(err) } });
@@ -1272,13 +1061,13 @@ var DecoderFfmpegAddon = class extends 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 });
+			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,
 				rationale: res.rationale,
@@ -1287,7 +1076,7 @@ var DecoderFfmpegAddon = class extends 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" };
 		}
 	}
@@ -1354,7 +1143,7 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 		};
 	}
 	wireCallbackSink(sessionId, session) {
-		const ringBuffer = new RingBuffer(FRAME_BUFFER_CAPACITY);
+		const ringBuffer = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
 		this.frameBuffers.set(sessionId, ringBuffer);
 		return session.onFrame((frame) => {
 			const { format } = frame;
@@ -1372,7 +1161,7 @@ var DecoderFfmpegAddon = class extends BaseAddon {
 		});
 	}
 	wireShmSink(sessionId, session) {
-		const handleRing = new RingBuffer(FRAME_BUFFER_CAPACITY);
+		const handleRing = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
 		this.handleBuffers.set(sessionId, handleRing);
 		return session.onFrameHandle((frame) => {
 			handleRing.push(frame.handle);
@@ -1384,6 +1173,8 @@ var DecoderFfmpegAddon = class extends 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);
@@ -1421,12 +1212,14 @@ var DecoderFfmpegAddon = class extends 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) {