@camstack/addon-pipeline 1.2.47 → 1.2.48

package/dist/stream-broker/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-C9Q1t0nT.js");
+const require_dist = require("../dist-CksKE1Sn.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_model_download_service_D8B_4ktF = require("../model-download-service-D8B-4ktF-7-YxE9Wx.js");
 let node_crypto = require("node:crypto");
@@ -5167,127 +5167,6 @@ function defaultId() {
 	counter += 1;
 	return `${Date.now().toString(36)}${counter.toString(36)}`;
 }
-/** A derive that has not finished by now will not finish inside the drain. */
-var GIF_RENDER_TIMEOUT_MS = 2e4;
-/**
-* The filter chain. Extracted so a test can assert the palette pair without
-* spawning ffmpeg — an argv test cannot see quality, but it can see a filter
-* that somebody deleted.
-*/
-function gifFilterComplex(input) {
-	const setpts = input.speed !== 1 ? `,setpts=PTS/${input.speed}` : "";
-	return `[0:v]fps=${input.fps}${setpts},scale=${input.maxWidth}:-2:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`;
-}
-/** The full argv, for the same reason. */
-function gifFromMp4Args(input) {
-	return [
-		"-y",
-		"-v",
-		"error",
-		"-f",
-		"mp4",
-		"-i",
-		"pipe:0",
-		"-filter_complex",
-		gifFilterComplex(input),
-		"-loop",
-		"0",
-		"-f",
-		"gif",
-		"pipe:1"
-	];
-}
-/**
-* Derive the gif. `null` on every failure — a notification that lost its gif is
-* a notification, and one that failed is not.
-*
-* The child is guaranteed dead before this settles: these run on every
-* notification that asks for a gif, and a leaked ffmpeg accumulates on the node
-* until somebody notices the host is slow.
-*/
-async function gifFromMp4(input) {
-	const args = gifFromMp4Args({
-		maxWidth: input.maxWidth ?? 640,
-		fps: input.fps ?? 8,
-		speed: input.speed ?? 1
-	});
-	const startedAt = Date.now();
-	try {
-		const bytes = await runGif(input, args);
-		input.logger?.info("nc gif: derived from the notification video", {
-			tags: { deviceId: input.deviceId },
-			meta: {
-				sourceBytes: input.mp4.length,
-				gifBytes: bytes.length,
-				width: input.maxWidth ?? 640,
-				fps: input.fps ?? 8,
-				encodeMs: Date.now() - startedAt
-			}
-		});
-		return bytes;
-	} catch (err) {
-		input.logger?.warn("nc gif: the derive failed — this notification ships without a gif", {
-			tags: { deviceId: input.deviceId },
-			meta: {
-				sourceBytes: input.mp4.length,
-				error: err instanceof Error ? err.message : String(err)
-			}
-		});
-		return null;
-	}
-}
-function runGif(input, args) {
-	return new Promise((resolve, reject) => {
-		const proc = input.spawnFn(input.ffmpegPath ?? "ffmpeg", [...args], { stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		] });
-		const chunks = [];
-		let stderrTail = "";
-		let done = false;
-		let timer = null;
-		const settle = (err, out) => {
-			if (done) return;
-			done = true;
-			if (timer !== null) clearTimeout(timer);
-			if (proc.exitCode === null && proc.signalCode === null) try {
-				proc.kill("SIGKILL");
-			} catch {}
-			try {
-				proc.stdout?.removeAllListeners();
-				proc.stderr?.removeAllListeners();
-				proc.stdin?.destroy();
-			} catch {}
-			if (err !== null) reject(err);
-			else resolve(out ?? new Uint8Array(0));
-		};
-		timer = setTimeout(() => settle(/* @__PURE__ */ new Error("gif derive timed out")), GIF_RENDER_TIMEOUT_MS);
-		timer.unref?.();
-		proc.stdout?.on("data", (c) => chunks.push(c));
-		proc.stderr?.on("data", (c) => {
-			stderrTail = (stderrTail + c.toString()).slice(-400);
-		});
-		proc.on("error", (err) => settle(err instanceof Error ? err : new Error(String(err))));
-		proc.on("close", (code) => {
-			if (code !== 0) {
-				settle(/* @__PURE__ */ new Error(`ffmpeg gif derive exited ${code}: ${stderrTail}`));
-				return;
-			}
-			const out = Buffer.concat(chunks);
-			if (out.byteLength === 0) {
-				settle(/* @__PURE__ */ new Error("gif derive produced no bytes"));
-				return;
-			}
-			const bytes = new Uint8Array(out.byteLength);
-			bytes.set(out);
-			settle(null, bytes);
-		});
-		proc.stdin?.on("error", () => {});
-		proc.stdin?.write(Buffer.from(input.mp4));
-		proc.stdin?.end();
-	});
-}
 //#endregion
 //#region src/stream-broker/webrtc/nal-utils.ts
 var NAL_START_CODE_4B = Buffer.from([
@@ -5968,6 +5847,41 @@ function toElementaryStream(window, sdpParameterSets) {
 }
 var RENDER_TIMEOUT_MS = 2e4;
 /**
+* The widest an event clip is RE-ENCODED at — 720p.
+*
+* Only ever reached when the render already forced a decode (a speed other than
+* real time, or an H.265 source). At real time the width must stay the source's
+* own, because an identity scale is precisely what `clipCanCopy` looks for.
+*
+* Measured on a real 615 720p window, `-preset veryfast`: crf 23 at 1280 is
+* 254 KB and 0.23 s of encode, against the 922 KB the copy of the same window
+* carried. Capping wider renditions here costs nothing an operator can see on a
+* phone and keeps the burst bounded on a hub that is already busy.
+*/
+var EVENT_CLIP_ENCODE_MAX_WIDTH = 1280;
+/**
+* The width to render an event clip at, given what the source is and whether
+* the caller asked for real time.
+*
+* One function because two call sites have to agree: the mux and the
+* `copy`/`encode` the production REPORTS. They disagreed once already — a
+* reported mode that does not match the render is a log line that lies.
+*/
+function eventClipEncodeWidth(sourceWidth, speed) {
+	const source = Math.max(1, Math.round(sourceWidth));
+	if (speed === 1) return source;
+	return Math.min(source, EVENT_CLIP_ENCODE_MAX_WIDTH);
+}
+/**
+* Format a frame rate for an ffmpeg filter argument.
+*
+* `12 / 4` must reach the filter as `3` and `15 / 4` as `3.75`, not as a float
+* tail that `av_parse_video_rate` then has to guess at.
+*/
+function ffmpegRate(rate) {
+	return String(Math.round(rate * 1e3) / 1e3);
+}
+/**
 * Whether this render can COPY the camera's own H.264 instead of re-encoding it.
 *
 * The ring already holds the camera's elementary stream. Re-encoding it is only
@@ -6003,6 +5917,7 @@ function clipFfmpegArgs(input) {
 	const demuxer = input.hevc === true ? "hevc" : "h264";
 	const speed = input.speed ?? 2;
 	const setpts = speed !== 1 ? `,setpts=PTS/${speed}` : "";
+	const gifSetpts = speed !== 1 ? `${setpts},fps=${ffmpegRate(input.fps * speed)}` : setpts;
 	if (input.format === "gif") return [
 		"-y",
 		"-f",
@@ -6010,7 +5925,7 @@ function clipFfmpegArgs(input) {
 		"-i",
 		"pipe:0",
 		"-filter_complex",
-		`[0:v]fps=${input.fps}${setpts},${scale},split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`,
+		`[0:v]fps=${ffmpegRate(input.fps)}${gifSetpts},${scale},split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`,
 		"-loop",
 		"0",
 		"-f",
@@ -6045,7 +5960,7 @@ function clipFfmpegArgs(input) {
 		"-preset",
 		"veryfast",
 		"-crf",
-		"28",
+		"23",
 		"-pix_fmt",
 		"yuv420p",
 		"-movflags",
@@ -6121,6 +6036,142 @@ async function renderPreBufferClip(input) {
 		proc.stdin?.end();
 	});
 }
+/**
+* The factor the derive must apply ON TOP of the speed the mp4 already carries.
+*
+* The gif is derived from the muxed mp4, so if that mux already ran `setpts` at
+* the caller's `speed`, applying the absolute gif rate again would compound
+* them — a 4× gif beside a 2× video would come out at 8×. Discounting here is
+* what keeps {@link GIF_SPEED} an ABSOLUTE rate against real time whatever the
+* video does.
+*/
+function gifDeriveSpeed(gifSpeed, videoSpeed) {
+	if (!Number.isFinite(videoSpeed) || videoSpeed <= 0) return gifSpeed;
+	return gifSpeed / videoSpeed;
+}
+/** A derive that has not finished by now will not finish inside the drain. */
+var GIF_RENDER_TIMEOUT_MS = 2e4;
+/**
+* The filter chain. Extracted so a test can assert the palette pair without
+* spawning ffmpeg — an argv test cannot see quality, but it can see a filter
+* that somebody deleted.
+*/
+function gifFilterComplex(input) {
+	const speed = input.speed > 0 ? input.speed : 1;
+	if (speed === 1) return `[0:v]fps=${ffmpegRate(input.fps)},scale=${input.maxWidth}:-2:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`;
+	return `[0:v]fps=${ffmpegRate(input.fps / speed)},setpts=PTS/${speed},fps=${ffmpegRate(input.fps)},scale=${input.maxWidth}:-2:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`;
+}
+/** The full argv, for the same reason. */
+function gifFromMp4Args(input) {
+	return [
+		"-y",
+		"-v",
+		"error",
+		"-f",
+		"mp4",
+		"-i",
+		"pipe:0",
+		"-filter_complex",
+		gifFilterComplex(input),
+		"-loop",
+		"0",
+		"-f",
+		"gif",
+		"pipe:1"
+	];
+}
+/**
+* Derive the gif. `null` on every failure — a notification that lost its gif is
+* a notification, and one that failed is not.
+*
+* The child is guaranteed dead before this settles: these run on every
+* notification that asks for a gif, and a leaked ffmpeg accumulates on the node
+* until somebody notices the host is slow.
+*/
+async function gifFromMp4(input) {
+	const args = gifFromMp4Args({
+		maxWidth: input.maxWidth ?? 640,
+		fps: input.fps ?? 12,
+		speed: input.speed ?? 4
+	});
+	const startedAt = Date.now();
+	try {
+		const bytes = await runGif(input, args);
+		input.logger?.info("nc gif: derived from the notification video", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				sourceBytes: input.mp4.length,
+				gifBytes: bytes.length,
+				width: input.maxWidth ?? 640,
+				fps: input.fps ?? 12,
+				speed: input.speed ?? 4,
+				encodeMs: Date.now() - startedAt
+			}
+		});
+		return bytes;
+	} catch (err) {
+		input.logger?.warn("nc gif: the derive failed — this notification ships without a gif", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				sourceBytes: input.mp4.length,
+				error: err instanceof Error ? err.message : String(err)
+			}
+		});
+		return null;
+	}
+}
+function runGif(input, args) {
+	return new Promise((resolve, reject) => {
+		const proc = input.spawnFn(input.ffmpegPath ?? "ffmpeg", [...args], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		const chunks = [];
+		let stderrTail = "";
+		let done = false;
+		let timer = null;
+		const settle = (err, out) => {
+			if (done) return;
+			done = true;
+			if (timer !== null) clearTimeout(timer);
+			if (proc.exitCode === null && proc.signalCode === null) try {
+				proc.kill("SIGKILL");
+			} catch {}
+			try {
+				proc.stdout?.removeAllListeners();
+				proc.stderr?.removeAllListeners();
+				proc.stdin?.destroy();
+			} catch {}
+			if (err !== null) reject(err);
+			else resolve(out ?? new Uint8Array(0));
+		};
+		timer = setTimeout(() => settle(/* @__PURE__ */ new Error("gif derive timed out")), GIF_RENDER_TIMEOUT_MS);
+		timer.unref?.();
+		proc.stdout?.on("data", (c) => chunks.push(c));
+		proc.stderr?.on("data", (c) => {
+			stderrTail = (stderrTail + c.toString()).slice(-400);
+		});
+		proc.on("error", (err) => settle(err instanceof Error ? err : new Error(String(err))));
+		proc.on("close", (code) => {
+			if (code !== 0) {
+				settle(/* @__PURE__ */ new Error(`ffmpeg gif derive exited ${code}: ${stderrTail}`));
+				return;
+			}
+			const out = Buffer.concat(chunks);
+			if (out.byteLength === 0) {
+				settle(/* @__PURE__ */ new Error("gif derive produced no bytes"));
+				return;
+			}
+			const bytes = new Uint8Array(out.byteLength);
+			bytes.set(out);
+			settle(null, bytes);
+		});
+		proc.stdin?.on("error", () => {});
+		proc.stdin?.write(Buffer.from(input.mp4));
+		proc.stdin?.end();
+	});
+}
 //#endregion
 //#region src/stream-broker/stream-broker/profile-restreamers.ts
 /**
@@ -15251,9 +15302,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 			postRollSec: input.postSeconds,
 			...preferred !== void 0 ? { profile: preferred } : {}
 		});
+		const clipWidth = eventClipEncodeWidth(cut.sourceWidth, input.speed);
 		const mp4 = await this.muxClipWindow(cut, {
 			format: "mp4",
-			maxWidth: Math.max(1, cut.sourceWidth),
+			maxWidth: clipWidth,
 			fps: 0,
 			speed: input.speed
 		});
@@ -15269,22 +15321,23 @@ var StreamBrokerManager = class StreamBrokerManager {
 			nodeId: this.localNodeId ?? "",
 			mime: "video/mp4",
 			bytes: mp4.byteLength,
-			width: cut.sourceWidth,
-			height: cut.sourceHeight
+			width: clipWidth,
+			height: scaledHeight(cut, clipWidth)
 		});
+		const gifSpeed = input.gifSpeed ?? 4;
 		if (input.kinds.includes("gif")) {
 			const gif = await gifFromMp4({
 				mp4,
 				deviceId: input.deviceId,
 				maxWidth: input.gifMaxWidth,
 				fps: input.gifFps,
-				speed: 1,
+				speed: gifDeriveSpeed(gifSpeed, input.speed),
 				...this.logger !== void 0 ? { logger: this.logger } : {},
 				spawnFn: node_child_process.spawn,
 				...this.ffmpegConfig.binaryPath !== void 0 ? { ffmpegPath: this.ffmpegConfig.binaryPath } : {}
 			});
 			if (gif !== null) {
-				const height = cut.sourceWidth > 0 ? Math.round(input.gifMaxWidth / cut.sourceWidth * cut.sourceHeight) : 0;
+				const height = scaledHeight(cut, input.gifMaxWidth);
 				media.push({
 					kind: "gif",
 					handle: this.eventMedia.put({
@@ -15303,7 +15356,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		}
 		const video = this.clipVideoMode(cut, {
 			format: "mp4",
-			maxWidth: Math.max(1, cut.sourceWidth),
+			maxWidth: clipWidth,
 			speed: input.speed
 		});
 		this.logger?.info("event media produced — one window, every container", {
@@ -15315,6 +15368,8 @@ var StreamBrokerManager = class StreamBrokerManager {
 				packets: cut.window.length,
 				kinds: [...input.kinds].join(","),
 				artifacts: media.map((m) => `${m.kind}:${m.bytes}`).join(" "),
+				speed: input.speed,
+				gifSpeed,
 				startOffsetMs: cut.coverage.fromTs - input.aroundMs,
 				endOffsetMs: cut.coverage.toTs - input.aroundMs
 			}
@@ -17572,6 +17627,17 @@ var StreamBrokerManager = class StreamBrokerManager {
 		}
 	}
 };
+/**
+* The height a render lands at, once `scale=W:-2` has picked it.
+*
+* `-2` means "keep the aspect, round to an EVEN number" — libx264 rejects an
+* odd dimension in yuv420p. Reporting the arithmetic without the rounding is
+* how an artifact ends up one pixel taller than the file it describes.
+*/
+function scaledHeight(cut, width) {
+	if (cut.sourceWidth <= 0 || cut.sourceHeight <= 0) return 0;
+	return 2 * Math.round(width / cut.sourceWidth * cut.sourceHeight / 2);
+}
 //#endregion
 //#region src/stream-broker/encode-profile-resolver.ts
 /**