@camstack/addon-pipeline 1.1.39 → 1.1.41

package/dist/session-decode/decode-worker-child.mjs

@@ -0,0 +1,543 @@
+import { n as isWorkerRequest } from "../worker-protocol-pk7qdYXt.mjs";
+//#region src/session-decode/frame-slot.ts
+function toReply(held) {
+	return {
+		frameId: held.frameId,
+		timestamp: held.timestamp,
+		width: held.width,
+		height: held.height
+	};
+}
+/**
+* Latest-wins decoded-frame slot + reserved-for-`toBuffer` holder +
+* pending-pull flag. One instance per decode-worker child session.
+*/
+var FrameSlot = class {
+	nextFrameId = 1;
+	slot = null;
+	/**
+	* The frame handed to the MOST RECENT `pull`, retained so a following
+	* `toBuffer(frameId)` still resolves even though `publish` keeps advancing
+	* the latest-wins `slot`. Freed when the next `pull` supersedes it (or on
+	* `free()`).
+	*/
+	reserved = null;
+	pendingPull = false;
+	/**
+	* Publish a newly decoded frame into the latest-wins slot, freeing
+	* whatever the slot held before (the drop-older half of "latest-wins").
+	* Returns the reply to send if a `pull` was pending (resolving it
+	* immediately and reserving the frame); otherwise returns `null` and the
+	* frame simply waits in the slot for the next `pull`.
+	*/
+	publish(frame, timestamp, minIntervalMs) {
+		if (minIntervalMs > 0 && this.slot && timestamp - this.slot.timestamp < minIntervalMs) {
+			frame.free();
+			return null;
+		}
+		const previous = this.slot;
+		const frameId = this.nextFrameId++;
+		this.slot = {
+			frameId,
+			frame,
+			timestamp,
+			width: frame.width,
+			height: frame.height
+		};
+		previous?.frame.free();
+		if (this.pendingPull) {
+			this.pendingPull = false;
+			return this.reserveSlot();
+		}
+		return null;
+	}
+	/**
+	* Hand out the newest slot frame and RESERVE it (freeing the previously
+	* reserved frame), clearing the slot. Returns `null` if no frame has been
+	* decoded yet — the caller should then call `markPendingPull()`.
+	*/
+	pull() {
+		if (!this.slot) return null;
+		return this.reserveSlot();
+	}
+	/** Record that a pull is waiting for the next `publish` to resolve it. */
+	markPendingPull() {
+		this.pendingPull = true;
+	}
+	/** The reserved frame for `frameId`, or `null` if unknown/stale. */
+	toBuffer(frameId) {
+		if (!this.reserved || this.reserved.frameId !== frameId) return null;
+		return this.reserved.frame;
+	}
+	/** Free both the slot and the reserved frame (teardown). */
+	free() {
+		this.slot?.frame.free();
+		this.slot = null;
+		this.reserved?.frame.free();
+		this.reserved = null;
+	}
+	reserveSlot() {
+		const held = this.slot;
+		if (!held) throw new Error("frame-slot: reserveSlot called with no slot held");
+		const previousReserved = this.reserved;
+		this.reserved = held;
+		this.slot = null;
+		previousReserved?.frame.free();
+		return toReply(held);
+	}
+};
+//#endregion
+//#region src/session-decode/decode-worker-child.ts
+/** Re-dial backoff on a transient dial error/EOF (mirrors the decoder's PULL_REDIAL_MS). */
+var REDIAL_MS = 3e3;
+var _nav = null;
+var _consts = null;
+async function getNodeAv() {
+	if (!_nav) _nav = await import("node-av");
+	return _nav;
+}
+async function getConstants() {
+	if (!_consts) _consts = await import("node-av/constants");
+	return _consts;
+}
+function errMessage(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+/**
+* RTSP low-latency demuxer options — mirrors
+* `addon-decoder-nodeav/src/pull-demuxer-options.ts` (duplicated here rather
+* than cross-imported: this file is a standalone forked entry point, not an
+* addon consumer of that package). `analyzeduration`/`probesize` stay small
+* but non-zero — zeroing them starves the Reolink rfc4571 restream demuxer.
+*/
+function buildDemuxerOptions() {
+	return {
+		rtsp_transport: "tcp",
+		fflags: "nobuffer",
+		analyzeduration: "1000000",
+		probesize: "1000000",
+		max_delay: "0",
+		reorder_queue_size: "0",
+		user_agent: "decode-worker"
+	};
+}
+/** Ordered hwaccel candidates per platform — first successful create() wins, else software. */
+function candidateBackends() {
+	switch (process.platform) {
+		case "darwin": return ["videotoolbox"];
+		case "linux": return [
+			"vaapi",
+			"qsv",
+			"cuda"
+		];
+		case "win32": return [
+			"d3d11va",
+			"dxva2",
+			"cuda"
+		];
+		default: return [];
+	}
+}
+/** Map a canonical backend name to the node-av `AV_HWDEVICE_TYPE_*` constant. */
+function backendToHwDeviceConst(backend, consts) {
+	switch (backend) {
+		case "videotoolbox": return consts.AV_HWDEVICE_TYPE_VIDEOTOOLBOX;
+		case "cuda":
+		case "nvdec": return consts.AV_HWDEVICE_TYPE_CUDA;
+		case "vaapi": return consts.AV_HWDEVICE_TYPE_VAAPI;
+		case "qsv": return consts.AV_HWDEVICE_TYPE_QSV;
+		case "d3d11va": return consts.AV_HWDEVICE_TYPE_D3D11VA;
+		case "dxva2": return consts.AV_HWDEVICE_TYPE_DXVA2;
+		case "amf": return consts.AV_HWDEVICE_TYPE_AMF;
+		case "vdpau": return consts.AV_HWDEVICE_TYPE_VDPAU;
+		case "drm": return consts.AV_HWDEVICE_TYPE_DRM;
+		default: return null;
+	}
+}
+/** Clamp to [min,max] then floor to the nearest even number (YUV420P chroma is 2x2 subsampled). */
+function clampEven(value, min, max) {
+	const bounded = Math.min(Math.max(value, min), max);
+	return bounded - bounded % 2;
+}
+/** Resolve `FrameImageOptions.crop` against the decoded frame's dimensions, defaulting to the full frame. */
+function resolveCropRegion(frameWidth, frameHeight, crop) {
+	const left = clampEven(crop?.left ?? 0, 0, Math.max(0, frameWidth - 2));
+	const top = clampEven(crop?.top ?? 0, 0, Math.max(0, frameHeight - 2));
+	return {
+		left,
+		top,
+		width: clampEven(crop?.width ?? frameWidth - left, 2, frameWidth - left),
+		height: clampEven(crop?.height ?? frameHeight - top, 2, frameHeight - top)
+	};
+}
+/** Resolve `FrameImageOptions.resize`, defaulting to the (already cropped) source dimensions. */
+function resolveResizeTarget(cropWidth, cropHeight, resize) {
+	if (!resize) return {
+		width: cropWidth,
+		height: cropHeight
+	};
+	return {
+		width: Math.max(1, Math.round(resize.width)),
+		height: Math.max(1, Math.round(resize.height))
+	};
+}
+/**
+* The forked child's whole runtime: decode-loop lifecycle, the latest-wins
+* frame slot, and the ROI scaler for `toBuffer`. One instance per process.
+*/
+var DecodeWorkerChild = class {
+	nav = null;
+	consts = null;
+	hwContext = null;
+	/**
+	* Reused software scaler + the geometry/format key it was built for.
+	* Building a fresh `SoftwareScaleContext` on EVERY `toBuffer` (24fps)
+	* churned native libav memory unboundedly (a persistent worker grew to
+	* ~10GB/h). Detection uses a stable ROI + resize target, so the scaler is
+	* built once and reused, rebuilt only when the key changes — mirroring the
+	* shared decoder session (`nodeav-decoder-session.ts`, which reuses one
+	* `this.scaler` for the same reason). Disposed in `teardown`.
+	*/
+	scaler = null;
+	scalerKey = "";
+	demuxer = null;
+	decoder = null;
+	abortController = null;
+	started = false;
+	stopped = false;
+	sessionFormat = "rgb";
+	minIntervalMs = 0;
+	/**
+	* The latest-wins decoded-frame slot + reserved-for-`toBuffer` holder +
+	* pending-pull flag — extracted to `FrameSlot` (Epic C P2 Task 2 / I2) so
+	* the reserve-on-pull invariant (`e3c78a9b`) is unit-tested without
+	* node-av. See that file's doc comment for the full semantics.
+	*/
+	frames = new FrameSlot();
+	/**
+	* Mirrors whether `this.frames` currently has a pull waiting, so
+	* `teardown` knows to resolve it with `{kind:'ended'}` — `FrameSlot`
+	* intentionally exposes no pending-pull query, only `markPendingPull()`,
+	* so the child tracks this in lockstep (set in `handlePull`, cleared
+	* whenever `consumeDecodedFrame`'s `publish` resolves it).
+	*/
+	pendingPull = false;
+	ended = false;
+	redialTimer = null;
+	handleMessage(message) {
+		if (!isWorkerRequest(message)) {
+			this.sendError("decode-worker-child: malformed request");
+			return;
+		}
+		switch (message.kind) {
+			case "start":
+				this.handleStart(message.source, message.opts);
+				return;
+			case "pull":
+				this.handlePull();
+				return;
+			case "toBuffer":
+				this.handleToBuffer(message.frameId, message.opts);
+				return;
+			case "stop":
+				this.handleStop();
+				return;
+		}
+	}
+	/** Channel teardown (explicit `stop` or the parent disconnecting) — dispose, then exit. */
+	teardown() {
+		this.stopped = true;
+		this.ended = true;
+		if (this.redialTimer) {
+			clearTimeout(this.redialTimer);
+			this.redialTimer = null;
+		}
+		this.abortController?.abort();
+		this.closeInput();
+		this.frames.free();
+		this.scaler?.[Symbol.dispose]?.();
+		this.scaler = null;
+		this.scalerKey = "";
+		this.hwContext?.[Symbol.dispose]?.();
+		this.hwContext = null;
+		if (this.pendingPull) {
+			this.pendingPull = false;
+			this.send({ kind: "ended" });
+		}
+	}
+	handleStart(source, opts) {
+		if (this.started) {
+			process.stderr.write("decode-worker-child: duplicate start ignored\n");
+			return;
+		}
+		this.started = true;
+		this.sessionFormat = opts.format ?? "rgb";
+		this.minIntervalMs = opts.fps && opts.fps > 0 ? 1e3 / opts.fps : 0;
+		this.runDecodeLoop(source.restreamUrl).catch((err) => {
+			this.sendError(`decode-worker-child: decode loop crashed — ${errMessage(err)}`);
+		});
+	}
+	handlePull() {
+		if (this.ended) {
+			this.send({ kind: "ended" });
+			return;
+		}
+		const reply = this.frames.pull();
+		if (reply) {
+			this.send(this.toFrameReply(reply));
+			return;
+		}
+		this.pendingPull = true;
+		this.frames.markPendingPull();
+	}
+	handleToBuffer(frameId, opts) {
+		const frame = this.frames.toBuffer(frameId);
+		if (!frame) {
+			this.sendError(`decode-worker-child: toBuffer for unknown or stale frameId ${frameId}`, frameId);
+			return;
+		}
+		try {
+			const bytes = this.scaleRoiToBuffer(frame, opts);
+			this.send({
+				kind: "buffer",
+				frameId,
+				bytes
+			});
+		} catch (err) {
+			this.sendError(`decode-worker-child: toBuffer failed — ${errMessage(err)}`, frameId);
+		}
+	}
+	handleStop() {
+		this.teardown();
+		process.exit(0);
+	}
+	async runDecodeLoop(url) {
+		const nav = await getNodeAv();
+		const C = await getConstants();
+		if (this.stopped) return;
+		this.nav = nav;
+		this.consts = C;
+		nav.Log.setLevel(C.AV_LOG_FATAL);
+		await this.ensureHwContext(nav, C);
+		while (!this.stopped) {
+			try {
+				await this.dialAndDecode(nav, C, url);
+			} catch (err) {
+				if (this.stopped) break;
+				process.stderr.write(`decode-worker-child: dial ended — re-dial scheduled: ${errMessage(err)}\n`);
+			} finally {
+				this.closeInput();
+			}
+			if (this.stopped) break;
+			await this.sleep(REDIAL_MS);
+		}
+	}
+	/**
+	* One dial: open the demuxer, pick the video stream, build a HW/SW decoder
+	* that downloads + normalises frames to YUV420P system memory (so the ROI
+	* scaler always reads plain software planes regardless of hwaccel), and
+	* pump `demuxer.packets → decoder.frames → consumeDecodedFrame` until the
+	* stream ends, errors, or teardown aborts it.
+	*
+	* Copied from `nodeav-decoder-session.ts` `pullDialAndDecode` (lines
+	* ~916-996): same demuxer options, same `rescale.pixelFormat: YUV420P`
+	* download-always contract (keeping decoded frames on the GPU leaked the
+	* VAAPI surface pool on every re-dial — see that file's comment), same
+	* `exitOnError: false` bad-frame tolerance.
+	*/
+	async dialAndDecode(nav, C, url) {
+		this.abortController = new AbortController();
+		const demuxer = await nav.Demuxer.open(url, {
+			options: buildDemuxerOptions(),
+			signal: this.abortController.signal
+		});
+		if (this.stopped) {
+			demuxer[Symbol.dispose]?.();
+			return;
+		}
+		this.demuxer = demuxer;
+		const videoStream = demuxer.video();
+		if (!videoStream) throw new Error("decode-worker-child: pull input has no video stream");
+		const decoder = await nav.Decoder.create(videoStream, {
+			...this.hwContext ? { hardware: this.hwContext } : {},
+			rescale: { pixelFormat: C.AV_PIX_FMT_YUV420P },
+			exitOnError: false
+		});
+		if (this.stopped) {
+			decoder[Symbol.dispose]?.();
+			return;
+		}
+		this.decoder = decoder;
+		for await (const frame of decoder.frames(demuxer.packets(videoStream.index))) {
+			if (this.stopped) break;
+			if (!frame) continue;
+			this.consumeDecodedFrame(frame);
+		}
+	}
+	/**
+	* Publish a decoded frame into the latest-wins slot (mirrors Scrypted's
+	* `libav.py:32,50-53` single-slot queue) via `FrameSlot`, which handles
+	* drop-older, the `minIntervalMs` throttle, and resolving a pending `pull`.
+	*/
+	consumeDecodedFrame(frame) {
+		if (frame.isHwFrame()) {
+			frame.free();
+			return;
+		}
+		const reply = this.frames.publish(frame, Date.now(), this.minIntervalMs);
+		if (reply) {
+			this.pendingPull = false;
+			this.send(this.toFrameReply(reply));
+		}
+	}
+	toFrameReply(reply) {
+		return {
+			kind: "frame",
+			frameId: reply.frameId,
+			timestamp: reply.timestamp,
+			width: reply.width,
+			height: reply.height,
+			format: this.sessionFormat
+		};
+	}
+	/**
+	* ROI `toBuffer`: crop (via plane-pointer offset, not a re-decode) + resize
+	* + format-convert a retained decoded frame with `SoftwareScaleContext`.
+	* Writes straight into a tightly-packed destination buffer via the
+	* low-level `scaleSync` (no `dstFrame` + row-strip step needed — the same
+	* zero-copy destination technique as `scaleIntoRingSlot` in
+	* `nodeav-decoder-session.ts`, adapted to also OFFSET the source planes so
+	* a single scaler call handles the crop.
+	*/
+	scaleRoiToBuffer(frame, opts) {
+		const nav = this.nav;
+		const C = this.consts;
+		if (!nav || !C) throw new Error("node-av not initialized");
+		const region = resolveCropRegion(frame.width, frame.height, opts?.crop);
+		const target = resolveResizeTarget(region.width, region.height, opts?.resize);
+		const format = opts?.format ?? this.sessionFormat;
+		const dstFmt = format === "gray" ? C.AV_PIX_FMT_GRAY8 : C.AV_PIX_FMT_RGB24;
+		const channels = format === "gray" ? 1 : 3;
+		const planes = frame.data;
+		const strides = frame.linesize;
+		const yPlane = planes?.[0];
+		const uPlane = planes?.[1];
+		const vPlane = planes?.[2];
+		if (!yPlane || !uPlane || !vPlane) throw new Error("decode-worker-child: decoded frame missing planar YUV420P data");
+		const yStride = strides[0] ?? 0;
+		const cStride = strides[1] ?? 0;
+		const ySlice = yPlane.subarray(region.top * yStride + region.left);
+		const uSlice = uPlane.subarray(region.top / 2 * cStride + region.left / 2);
+		const vSlice = vPlane.subarray(region.top / 2 * cStride + region.left / 2);
+		const scaler = this.ensureScaler(nav, C, region.width, region.height, target.width, target.height, dstFmt);
+		const dstStride = target.width * channels;
+		const dstBuffer = Buffer.allocUnsafe(dstStride * target.height);
+		const scaledHeight = scaler.scaleSync([
+			ySlice,
+			uSlice,
+			vSlice
+		], [
+			yStride,
+			cStride,
+			cStride
+		], 0, region.height, [dstBuffer], [dstStride]);
+		if (scaledHeight < 0) throw new Error(`sws_scale failed: ${scaledHeight}`);
+		if (scaledHeight !== target.height) throw new Error(`scaler produced ${scaledHeight} of ${target.height} rows`);
+		return dstBuffer;
+	}
+	/**
+	* Build-once / reuse the {@link NavScaler} for a given src+dst geometry and
+	* dst format. Rebuilt (old disposed) only when the key changes — detection's
+	* ROI + resize target are stable, so this is a per-worker singleton in the
+	* steady state. Replaces the previous per-frame `new SoftwareScaleContext()`
+	* that leaked native libav memory at frame rate. Synchronous + single-thread
+	* (Node), so no epoch/race guard is needed (unlike the async shared session).
+	*/
+	ensureScaler(nav, C, srcW, srcH, dstW, dstH, dstFmt) {
+		const key = `${srcW}x${srcH}->${dstW}x${dstH}:${dstFmt}`;
+		const cached = this.scaler;
+		if (cached && key === this.scalerKey) return cached;
+		this.scaler?.[Symbol.dispose]?.();
+		this.scaler = null;
+		this.scalerKey = "";
+		const scaler = new nav.SoftwareScaleContext();
+		scaler.getContext(srcW, srcH, C.AV_PIX_FMT_YUV420P, dstW, dstH, dstFmt, C.SWS_FAST_BILINEAR);
+		const initRet = scaler.initContext();
+		if (initRet < 0) {
+			scaler[Symbol.dispose]?.();
+			throw new Error(`sws_init_context failed: ${initRet}`);
+		}
+		this.scaler = scaler;
+		this.scalerKey = key;
+		return scaler;
+	}
+	/**
+	* Resolve the HW context ONCE (reused across every re-dial, freed in
+	* `teardown`). Tries the platform's ordered candidate list; the first
+	* `HardwareContext.create` that succeeds wins; every failure falls through
+	* to software decode (`hardware` omitted from `Decoder.create`).
+	*/
+	async ensureHwContext(nav, C) {
+		for (const backend of candidateBackends()) {
+			const deviceType = backendToHwDeviceConst(backend, C);
+			if (deviceType === null) continue;
+			const hw = nav.HardwareContext.create(deviceType);
+			if (!hw) {
+				process.stderr.write(`decode-worker-child: hwaccel candidate '${backend}' failed — trying next\n`);
+				continue;
+			}
+			this.hwContext = hw;
+			return;
+		}
+		process.stderr.write("decode-worker-child: no hwaccel backend available — using software decode\n");
+	}
+	/** Interruptible re-dial backoff — `teardown` clears the pending timer. */
+	sleep(ms) {
+		return new Promise((resolve) => {
+			this.redialTimer = setTimeout(() => {
+				this.redialTimer = null;
+				resolve();
+			}, ms);
+		});
+	}
+	/** Dispose the CURRENT dial's demuxer + decoder (the HW context is reused across dials). */
+	closeInput() {
+		this.decoder?.[Symbol.dispose]?.();
+		this.decoder = null;
+		this.demuxer?.[Symbol.dispose]?.();
+		this.demuxer = null;
+	}
+	send(reply) {
+		process.send?.(reply);
+	}
+	sendError(message, frameId) {
+		process.stderr.write(`${message}\n`);
+		this.send(frameId === void 0 ? {
+			kind: "error",
+			message
+		} : {
+			kind: "error",
+			message,
+			frameId
+		});
+	}
+};
+var worker = new DecodeWorkerChild();
+process.on("message", (message) => {
+	worker.handleMessage(message);
+});
+process.on("disconnect", () => {
+	worker.teardown();
+	process.exit(0);
+});
+process.on("uncaughtException", (err) => {
+	process.stderr.write(`decode-worker-child: uncaught exception — ${errMessage(err)}\n`);
+	worker.teardown();
+	process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+	process.stderr.write(`decode-worker-child: unhandled rejection — ${errMessage(reason)}\n`);
+});
+//#endregion
+export { DecodeWorkerChild };