@camstack/addon-pipeline 1.2.220 → 1.2.221

package/dist/stream-broker/index.js

@@ -3,12 +3,12 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-ByPsWlTa.js");
-const require_node = require("../node-CNPnaux4.js");
+const require_dist = require("../dist-ATDfcxgL.js");
+const require_node = require("../node-C5jnTgpv.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
-const require_segment_demux_js = require("../segment-demux-js-CZefXDLx.js");
+const require_segment_demux_js = require("../segment-demux-js-o9KBAz9p.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -8383,106 +8383,72 @@ function depacketizeRfc3640(payload, opts = {
 //#region src/stream-broker/rtsp/audio-rtp-decoder.ts
 /** G.711 is 8 kHz by definition (RFC 3551): the plane carries that rate. */
 var G711_SAMPLE_RATE = 8e3;
-var CHUNK_SAMPLES = G711_SAMPLE_RATE * 500 / 1e3;
+/** One G.711 byte is one sample, so samples and bytes are the same count. */
+var CHUNK_BYTES = G711_SAMPLE_RATE * 500 / 1e3;
+/** The chunk `format` each RTP codec produces. */
+var CODEC_FORMAT = {
+	PCMU: "pcmu",
+	PCMA: "pcma"
+};
 /**
-* Decodes G.711 audio RTP packets into PCM f32le chunks at 8 kHz.
+* Chunks G.711 audio RTP payloads into ~0.5 s coded chunks at 8 kHz.
 *
-* Buffers decoded samples and emits a DecodedAudioChunk when ~0.5 s has
-* accumulated (4000 samples, 16 000 bytes).
+* Buffers payload bytes and emits a `DecodedAudioChunk` carrying the source
+* codec once ~0.5 s has accumulated (4000 bytes).
 */
 var AudioRtpDecoder = class {
-	codec;
+	format;
 	onChunk;
 	buffer;
 	bufferOffset = 0;
 	constructor(codec, onChunk) {
-		this.codec = codec;
+		this.format = CODEC_FORMAT[codec];
 		this.onChunk = onChunk;
-		this.buffer = new Float32Array(CHUNK_SAMPLES);
+		this.buffer = Buffer.allocUnsafe(CHUNK_BYTES);
 	}
 	/**
-	* Process a raw RTP packet (header + payload).
-	* Strips the 12-byte RTP header and decodes the G.711 payload: one byte,
-	* one 8 kHz sample. Nothing is interpolated here.
+	* Process a raw RTP packet (header + payload). Strips the 12-byte RTP header
+	* and appends the payload bytes verbatim, emitting whenever a chunk fills.
+	* A payload larger than the remaining room spans chunks.
 	*/
 	processPacket(rtpData) {
 		if (rtpData.length <= 12) return;
 		const payload = rtpData.subarray(12);
-		const decode = this.codec === "PCMU" ? decodeUlaw : decodeAlaw;
-		for (let i = 0; i < payload.length; i++) this.pushSample(decode(payload[i]));
+		let consumed = 0;
+		while (consumed < payload.length) {
+			const room = CHUNK_BYTES - this.bufferOffset;
+			const take = Math.min(room, payload.length - consumed);
+			payload.copy(this.buffer, this.bufferOffset, consumed, consumed + take);
+			this.bufferOffset += take;
+			consumed += take;
+			if (this.bufferOffset >= CHUNK_BYTES) this.emit();
+		}
 	}
-	/** Flush any remaining buffered samples as a partial chunk. */
+	/** Flush any remaining buffered bytes as a partial chunk. */
 	flush() {
 		if (this.bufferOffset === 0) return;
-		const data = Buffer.from(this.buffer.buffer, this.buffer.byteOffset, this.bufferOffset * 4);
+		this.emit();
+	}
+	/** Reset the chunker state. */
+	reset() {
+		this.bufferOffset = 0;
+	}
+	/**
+	* Emit what is buffered and start a fresh chunk. The bytes are COPIED out:
+	* the accumulator is reused, and the plane holds every queued chunk by
+	* reference until its consumer polls.
+	*/
+	emit() {
 		this.onChunk({
-			data: Buffer.from(data),
+			data: Buffer.from(this.buffer.subarray(0, this.bufferOffset)),
 			sampleRate: G711_SAMPLE_RATE,
 			channels: 1,
-			timestamp: Date.now()
+			timestamp: Date.now(),
+			format: this.format
 		});
 		this.bufferOffset = 0;
 	}
-	/** Reset the decoder state. */
-	reset() {
-		this.bufferOffset = 0;
-	}
-	pushSample(sample) {
-		this.buffer[this.bufferOffset++] = sample;
-		if (this.bufferOffset >= CHUNK_SAMPLES) {
-			const data = Buffer.from(this.buffer.buffer, this.buffer.byteOffset, CHUNK_SAMPLES * 4);
-			this.onChunk({
-				data: Buffer.from(data),
-				sampleRate: G711_SAMPLE_RATE,
-				channels: 1,
-				timestamp: Date.now()
-			});
-			this.bufferOffset = 0;
-		}
-	}
 };
-/** μ-law compressed byte → normalized float [-1.0, 1.0]. */
-function decodeUlaw(byte) {
-	return ULAW_TABLE[byte];
-}
-/** A-law compressed byte → normalized float [-1.0, 1.0]. */
-function decodeAlaw(byte) {
-	return ALAW_TABLE[byte];
-}
-/**
-* Build the μ-law decode table (ITU-T G.711).
-* Each of the 256 possible byte values maps to a 16-bit PCM sample,
-* which we normalize to [-1.0, 1.0] for f32le output.
-*/
-function buildUlawTable() {
-	const table = new Float32Array(256);
-	for (let i = 0; i < 256; i++) {
-		const complemented = ~i & 255;
-		const sign = (complemented & 128) !== 0 ? -1 : 1;
-		const exponent = complemented >> 4 & 7;
-		table[i] = sign * ((2 * (complemented & 15) + 33 << exponent) - 33) / 32768;
-	}
-	return table;
-}
-/**
-* Build the A-law decode table (ITU-T G.711).
-*/
-function buildAlawTable() {
-	const table = new Float32Array(256);
-	for (let i = 0; i < 256; i++) {
-		const xored = i ^ 85;
-		const sign = (xored & 128) !== 0 ? -1 : 1;
-		const exponent = xored >> 4 & 7;
-		const mantissa = xored & 15;
-		let magnitude;
-		if (exponent === 0) magnitude = 2 * mantissa + 1;
-		else magnitude = 2 * mantissa + 33 << exponent - 1;
-		table[i] = sign * magnitude / 32768;
-	}
-	return table;
-}
-var ULAW_TABLE = buildUlawTable();
-var ALAW_TABLE = buildAlawTable();
 //#endregion
 //#region src/stream-broker/rtsp/ffmpeg-source-reader.ts
 /**
@@ -9480,6 +9446,47 @@ function extractQuoted(header, key) {
 */
 var AUDIO_QUEUE_CAPACITY = 64;
 /**
+* How long a subscription may go without a `pull` before the plane releases it
+* (D461).
+*
+* Until 2026-09-11 the one subscriber was `pipeline-orchestrator`, which the
+* hub restarts alongside the broker, and an abandoned subscription was a
+* theoretical leak. D461 moved the poller into `audio-analyzer`, which may sit
+* on another node and may die without the orchestrator's detach ever
+* arriving — and on THIS plane an orphan is not merely a queue nobody drains.
+* `subscriberCount` is what `hasDemand()` reads, so one orphan pins the
+* broker's source dial and its decode session open for the broker's whole
+* life: a camera nobody is listening to, kept streaming and decoding by a dead
+* process.
+*
+* The bound has to clear the longest LEGITIMATE gap between two polls. The
+* poller awaits its consumer per chunk, and the consumer is now the classifier
+* itself, whose `classify` carries a 30 s timeout — so a gap of tens of
+* seconds is healthy. Two minutes is past every one of those and well past the
+* ~30 s of audio the FIFO can hold, so a subscription this idle has already
+* lost audio and cannot be serving anyone.
+*/
+var AUDIO_SUBSCRIPTION_IDLE_MS = 12e4;
+/** `format` is optional on the wire and its absence means `f32le` (D455). */
+function formatOf(chunk) {
+	return chunk.format ?? "f32le";
+}
+/**
+* Build the f32le twin of a coded chunk. Everything but `data` and `format`
+* is carried over — the rate, the channel count and the timestamp describe the
+* audio, not its encoding.
+*/
+function expandChunk(chunk, sourceFormat) {
+	const bytes = require_dist.expandAudioChunkToF32le(chunk.data, sourceFormat);
+	return {
+		data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+		sampleRate: chunk.sampleRate,
+		channels: chunk.channels,
+		timestamp: chunk.timestamp,
+		format: "f32le"
+	};
+}
+/**
 * Owns the broker's decoded audio-chunk subscriptions. The broker feeds every
 * decoded `DecodedAudioChunk` into `fanout`; each subscription's poll loop
 * drains its own FIFO queue via `pull`.
@@ -9487,8 +9494,12 @@ var AUDIO_QUEUE_CAPACITY = 64;
 var AudioChunkPlane = class {
 	logger;
 	subscriptions = /* @__PURE__ */ new Map();
-	constructor(logger) {
+	/** Last `reapIdle` sweep — the lease is checked on a cadence, not per chunk. */
+	lastReapAt = Date.now();
+	onSubscriptionsReaped;
+	constructor(logger, onSubscriptionsReaped) {
 		this.logger = logger;
+		this.onSubscriptionsReaped = onSubscriptionsReaped;
 	}
 	/** Number of active audio-chunk subscriptions — surfaced as audio demand. */
 	get subscriberCount() {
@@ -9505,12 +9516,16 @@ var AudioChunkPlane = class {
 			tag: input?.tag ?? "unknown",
 			subscribedAt: Date.now(),
 			queue: new require_dist.RingBuffer(AUDIO_QUEUE_CAPACITY),
-			chunksDelivered: 0
+			accept: new Set(input?.accept ?? []),
+			servedKey: null,
+			chunksDelivered: 0,
+			lastPulledAt: Date.now()
 		};
 		this.subscriptions.set(subscriptionId, subscription);
 		this.logger?.info("audio-chunk subscription added", { meta: {
 			subscriptionId,
-			tag: subscription.tag
+			tag: subscription.tag,
+			accept: input?.accept ?? []
 		} });
 		return { subscriptionId };
 	}
@@ -9522,10 +9537,44 @@ var AudioChunkPlane = class {
 	pull(subscriptionId, maxCount) {
 		const subscription = this.subscriptions.get(subscriptionId);
 		if (!subscription) return [];
+		subscription.lastPulledAt = Date.now();
 		const chunks = subscription.queue.drain(maxCount);
 		subscription.chunksDelivered += chunks.length;
 		return chunks;
 	}
+	/**
+	* Release every subscription nobody has drained for
+	* {@link AUDIO_SUBSCRIPTION_IDLE_MS}, and NAME each one (D461, D427).
+	*
+	* The lease is the net under the ownership split: the subscriber lives in a
+	* process the orchestrator does not supervise, so a missed `detachDevice`
+	* has to be survivable rather than trusted. It is deliberately driven from
+	* `fanout` — the plane has no clock of its own, and the moment a dead
+	* consumer costs anything is the moment there is a chunk to put in its
+	* queue. A plane with nothing flowing has nothing to reclaim.
+	*
+	* Returns the ids released so the broker can re-evaluate its demand; an
+	* orphan that is dropped but still counted would have fixed nothing.
+	*/
+	reapIdle(now = Date.now()) {
+		const reaped = [];
+		for (const subscription of [...this.subscriptions.values()]) {
+			const idleMs = now - subscription.lastPulledAt;
+			if (idleMs < 12e4) continue;
+			this.subscriptions.delete(subscription.id);
+			reaped.push(subscription.id);
+			this.logger?.warn("audio-chunk subscription REAPED — nobody drained it", { meta: {
+				subscriptionId: subscription.id,
+				tag: subscription.tag,
+				idleMs,
+				leaseMs: AUDIO_SUBSCRIPTION_IDLE_MS,
+				queued: subscription.queue.size,
+				chunksDelivered: subscription.chunksDelivered,
+				hint: "the consumer process died without detaching — its subscription was holding this broker in demand"
+			} });
+		}
+		return reaped;
+	}
 	/** Release a subscription. Returns `true` when a known subscription was released. */
 	unsubscribe(subscriptionId) {
 		const existed = this.subscriptions.delete(subscriptionId);
@@ -9536,9 +9585,67 @@ var AudioChunkPlane = class {
 	* Fan one decoded `DecodedAudioChunk` into every active subscription's FIFO
 	* queue. A full queue drops its oldest chunk (bounded safety valve for a
 	* stalled consumer). No-op when there are no subscriptions.
+	*
+	* ## The format each subscription gets (D455)
+	*
+	* The decoder now hands this plane the SOURCE bytes — one G.711 byte per
+	* sample instead of four f32le ones — because the plane crosses hub-main
+	* twice on its way to the analyzer and every leg was paying the expansion.
+	* A subscription receives those bytes only if it DECLARED it can read them;
+	* otherwise the plane expands to `f32le` here, which is byte-for-byte what
+	* every consumer received before this existed.
+	*
+	* The expansion is done ONCE per fanout and shared by every subscription
+	* that needs it: the chunk is immutable and the queue holds references.
 	*/
 	fanout(chunk) {
-		for (const subscription of this.subscriptions.values()) subscription.queue.push(chunk);
+		this.maybeReap();
+		const sourceFormat = formatOf(chunk);
+		let expanded = null;
+		for (const subscription of this.subscriptions.values()) {
+			if (sourceFormat === "f32le" || subscription.accept.has(sourceFormat)) {
+				this.noteServed(subscription, sourceFormat, sourceFormat);
+				subscription.queue.push(chunk);
+				continue;
+			}
+			expanded ??= expandChunk(chunk, sourceFormat);
+			this.noteServed(subscription, sourceFormat, "f32le");
+			subscription.queue.push(expanded);
+		}
+	}
+	/**
+	* Run the idle-lease sweep on a cadence rather than on every chunk. A quarter
+	* of the lease bounds how long an orphan outlives its bound by, and keeps
+	* the per-chunk cost of `fanout` a single clock read.
+	*/
+	maybeReap() {
+		const now = Date.now();
+		if (now - this.lastReapAt < 12e4 / 4) return;
+		this.lastReapAt = now;
+		if (this.reapIdle(now).length > 0) this.onSubscriptionsReaped?.();
+	}
+	/**
+	* Say what a subscription is being served — once, and again on every change.
+	*
+	* The audio decision of a relay is never silent (D427). Two things this line
+	* answers that nothing else can: a consumer receiving a format it did not
+	* expect (the failure that would otherwise surface as a level of +43 dBFS
+	* with no cause), and a leg still paying 4x because its consumer declared no
+	* `accept` — `expanded: true` is the byte cost, named where it is incurred.
+	*/
+	noteServed(subscription, sourceFormat, servedFormat) {
+		const key = `${sourceFormat}>${servedFormat}`;
+		if (subscription.servedKey === key) return;
+		const previous = subscription.servedKey;
+		subscription.servedKey = key;
+		this.logger?.info("audio-chunk subscription serving", { meta: {
+			subscriptionId: subscription.id,
+			tag: subscription.tag,
+			sourceFormat,
+			servedFormat,
+			expanded: servedFormat !== sourceFormat,
+			previous
+		} });
 	}
 	/** Diagnostic snapshot of every active audio-chunk subscription. */
 	listSubscribers() {
@@ -11836,7 +11943,7 @@ var StreamBroker = class StreamBroker {
 		});
 		this.preBuffer = new EncodedRingBuffer(StreamBroker.DEFAULT_PRE_BUFFER_SEC);
 		this.decoderSeedBuffer = new EncodedRingBuffer(StreamBroker.DECODER_SEED_BUFFER_SEC);
-		this.audioChunkPlane = new AudioChunkPlane(logger?.child("audio-chunk-plane"));
+		this.audioChunkPlane = new AudioChunkPlane(logger?.child("audio-chunk-plane"), () => this.checkDemand());
 		this.rtspRestreamer.onSessionCountChanged(() => this.checkDemand());
 		this.pipeServer.onClientCountChanged(() => this.checkDemand());
 	}
@@ -13191,7 +13298,10 @@ var StreamBroker = class StreamBroker {
 	subscribeAudioChunks(options) {
 		const tag = options?.tag;
 		if (!tag) this.logger?.warn(`subscribeAudioChunks called without tag — listClients will show 'unknown'`);
-		const result = this.audioChunkPlane.subscribe({ tag });
+		const result = this.audioChunkPlane.subscribe({
+			tag,
+			accept: options?.accept
+		});
 		this.checkDemand();
 		return result;
 	}
@@ -13671,16 +13781,19 @@ var StreamBroker = class StreamBroker {
 				const codecUpper = audioTrack.codec.toUpperCase();
 				this.audioCodec = codecUpper;
 				const supportedNative = codecUpper === "PCMU" || codecUpper === "PCMA";
-				this.logger?.info("audio: track detected", { meta: {
-					codec: audioTrack.codec,
-					codecUpper,
-					clockRate: audioTrack.clockRate,
-					channels: audioTrack.channels,
-					fmtpKeys: Object.keys(audioTrack.fmtp),
-					hasConfigHex: "config" in audioTrack.fmtp || "CONFIG" in audioTrack.fmtp,
-					audioCodecApiAvailable: this.audioCodecApi !== null,
-					supportedNative
-				} });
+				this.logger?.info("audio: track detected", {
+					tags: { deviceId: this.numericDeviceId },
+					meta: {
+						codec: audioTrack.codec,
+						codecUpper,
+						clockRate: audioTrack.clockRate,
+						channels: audioTrack.channels,
+						fmtpKeys: Object.keys(audioTrack.fmtp),
+						hasConfigHex: "config" in audioTrack.fmtp || "CONFIG" in audioTrack.fmtp,
+						audioCodecApiAvailable: this.audioCodecApi !== null,
+						supportedNative
+					}
+				});
 				let supported = supportedNative;
 				let effectiveSampleRate = audioTrack.clockRate;
 				let effectiveChannels = audioTrack.channels;
@@ -13688,13 +13801,17 @@ var StreamBroker = class StreamBroker {
 					this.audioRtpDecoder = new AudioRtpDecoder(codecUpper, (chunk) => {
 						this.audioChunkPlane.fanout(chunk);
 					});
-					this.logger?.info("native: audio decoder initialized", { meta: {
-						codec: codecUpper,
-						sampleRate: audioTrack.clockRate,
-						channels: audioTrack.channels,
-						planeSampleRate: G711_SAMPLE_RATE,
-						planeFormat: "f32le"
-					} });
+					this.logger?.info("native: audio decoder initialized", {
+						tags: { deviceId: this.numericDeviceId },
+						meta: {
+							codec: codecUpper,
+							sampleRate: audioTrack.clockRate,
+							channels: audioTrack.channels,
+							planeSampleRate: G711_SAMPLE_RATE,
+							planeFormat: codecUpper === "PCMA" ? "pcma" : "pcmu",
+							preD459LevelDeficitDb: Math.round(require_dist.G711_SCALE_CORRECTION_DB[codecUpper === "PCMA" ? "PCMA" : "PCMU"] * 100) / 100
+						}
+					});
 				} else if (this.audioCodecApi) {
 					const capCfg = this.buildAudioCodecSessionConfig(audioTrack);
 					if (capCfg) {
@@ -17471,7 +17588,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		await this.ensureBrokerForId(input.brokerId);
 		const broker = this.brokers.get(input.brokerId);
 		if (!broker) throw new Error(`stream-broker: no broker for "${input.brokerId}"`);
-		const result = broker.subscribeAudioChunks({ tag: input.tag });
+		const result = broker.subscribeAudioChunks({
+			tag: input.tag,
+			accept: input.accept
+		});
 		this.audioSubscriptionBroker.set(result.subscriptionId, input.brokerId);
 		return result;
 	}