@camstack/addon-pipeline 1.2.363 → 1.2.364

package/dist/stream-broker/index.js

@@ -3731,7 +3731,12 @@ var RtspRestreamer = class {
 	* Forwarded directly to all connected RTSP sessions — zero re-packetization.
 	*
 	* @param rtpData Complete RTP packet (header + payload)
-	* @param isKeyframe True if this packet is part of a keyframe access unit
+	* @param isKeyframe True if this packet is part of a keyframe ACCESS UNIT —
+	*   judged per picture by the broker's `RtpAccessUnitTracker`: every
+	*   fragment of a fragmented IDR and a prefix SEI inside the picture carry
+	*   it, not only the packet that completed an IRAP NAL. The keyframe cache
+	*   below collects exactly that run, and the transition into it is the
+	*   once-per-picture `keyframeAuStart` the sessions resume and count on.
 	* @param isParameterSet True if this packet contains SPS/PPS/VPS
 	*/
 	pushRtpPassthrough(rtpData, isKeyframe, isParameterSet) {
@@ -3747,14 +3752,14 @@ var RtspRestreamer = class {
 				this.lastKeyframeRtpBytes = 0;
 			}
 		}
+		if (this.collectingKeyframeRtp && !isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
 		if (this.collectingKeyframeRtp) {
 			this.lastKeyframeRtpPackets.push({
 				data: Buffer.from(rtpData),
 				marker: rtpPacket.marker
 			});
 			this.lastKeyframeRtpBytes += rtpData.length;
-			if (!isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
-			else if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
+			if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
 				this.warnCacheCapExceeded("rtp", this.lastKeyframeRtpBytes, this.lastKeyframeRtpPackets.length);
 				this.lastKeyframeRtpPackets = [];
 				this.lastKeyframeRtpBytes = 0;
@@ -3767,17 +3772,16 @@ var RtspRestreamer = class {
 			if (!session.isPlaying()) continue;
 			this.pendingKeyframe.delete(session.getSessionId());
 		}
-		const keyframeAu = isKeyframe || isParameterSet;
 		for (const session of this.sessions.values()) {
 			const sessionId = session.getSessionId();
 			if (this.activeReplays.get(sessionId)?.enqueue({
 				packet: rtpPacket,
 				prime: false,
-				keyframeAuStart: keyframeAu
+				keyframeAuStart
 			})) continue;
 			if (this.pendingKeyframe.has(sessionId)) continue;
 			if (!session.isPlaying()) continue;
-			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAu));
+			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAuStart));
 		}
 	}
 	/**
@@ -10128,6 +10132,16 @@ function allocAnnexBNal(byteLength) {
 	buf[3] = 1;
 	return buf;
 }
+var NO_PAYLOAD_CLASS = {
+	keyframe: false,
+	parameterSet: false
+};
+function isH265IrapType(type) {
+	return type >= H265_NAL_IRAP_MIN && type <= H265_NAL_IRAP_MAX;
+}
+function isH265ParameterSetType(type) {
+	return type === H265_NAL_VPS || type === H265_NAL_SPS || type === H265_NAL_PPS;
+}
 /** Total byte length of the reassembly fragments, without allocating a closure. */
 function totalFragmentBytes(fragments) {
 	let total = 0;
@@ -10173,16 +10187,92 @@ var RtpDepacketizer = class {
 	}
 	/**
 	* Process a raw RTP packet (including 12-byte RTP header).
-	* Emits zero or more complete NAL units via the callback.
+	* Emits zero or more complete NAL units via the callback and returns what
+	* THIS packet carried ({@link RtpPacketClass}) — `null` for a packet too
+	* short to be RTP with a payload.
 	*/
 	processPacket(rtpData) {
-		if (rtpData.length < 12) return;
+		if (rtpData.length < 12) return null;
 		const marker = (rtpData[1] & 128) !== 0;
 		const timestamp = rtpData.readUInt32BE(4);
 		const payload = rtpData.subarray(12);
-		if (payload.length === 0) return;
+		if (payload.length === 0) return null;
+		const carried = this.codec === "h264" ? this.classifyH264Payload(payload) : this.classifyH265Payload(payload);
 		if (this.codec === "h264") this.processH264(payload, timestamp, marker);
 		else this.processH265(payload, timestamp, marker);
+		return {
+			timestamp,
+			marker,
+			keyframe: carried.keyframe,
+			parameterSet: carried.parameterSet
+		};
+	}
+	/** H.264: single NAL by its type; STAP-A by every aggregated type; FU-A by the FU header. */
+	classifyH264Payload(payload) {
+		const nalType = payload[0] & 31;
+		if (nalType === H264_NAL_STAP_A) {
+			let keyframe = false;
+			let parameterSet = false;
+			let offset = 1;
+			while (offset + 2 <= payload.length) {
+				const nalSize = payload.readUInt16BE(offset);
+				offset += 2;
+				if (nalSize === 0 || offset + nalSize > payload.length) break;
+				const type = payload[offset] & 31;
+				keyframe ||= type === H264_NAL_IDR;
+				parameterSet ||= type === H264_NAL_SPS || type === H264_NAL_PPS;
+				offset += nalSize;
+			}
+			return {
+				keyframe,
+				parameterSet
+			};
+		}
+		if (nalType === 28) {
+			if (payload.length < 2) return NO_PAYLOAD_CLASS;
+			return {
+				keyframe: (payload[1] & 31) === H264_NAL_IDR,
+				parameterSet: false
+			};
+		}
+		return {
+			keyframe: nalType === H264_NAL_IDR,
+			parameterSet: nalType === H264_NAL_SPS || nalType === H264_NAL_PPS
+		};
+	}
+	/** H.265: single NAL by its type; AP by every aggregated type; FU by the FU header. */
+	classifyH265Payload(payload) {
+		if (payload.length < 2) return NO_PAYLOAD_CLASS;
+		const nalType = payload[0] >> 1 & 63;
+		if (nalType === H265_NAL_AP) {
+			let keyframe = false;
+			let parameterSet = false;
+			let offset = 2;
+			while (offset + 2 <= payload.length) {
+				const nalSize = payload.readUInt16BE(offset);
+				offset += 2;
+				if (nalSize === 0 || offset + nalSize > payload.length) break;
+				const type = payload[offset] >> 1 & 63;
+				keyframe ||= isH265IrapType(type);
+				parameterSet ||= isH265ParameterSetType(type);
+				offset += nalSize;
+			}
+			return {
+				keyframe,
+				parameterSet
+			};
+		}
+		if (nalType === 49) {
+			if (payload.length < 3) return NO_PAYLOAD_CLASS;
+			return {
+				keyframe: isH265IrapType(payload[2] & 63),
+				parameterSet: false
+			};
+		}
+		return {
+			keyframe: isH265IrapType(nalType),
+			parameterSet: isH265ParameterSetType(nalType)
+		};
 	}
 	processH264(payload, timestamp, marker) {
 		const nalType = payload[0] & 31;
@@ -10328,6 +10418,138 @@ var RtpDepacketizer = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/rtsp/rtp-access-unit-tracker.ts
+/**
+* Tracks access-unit membership across the source RTP packets of ONE stream.
+*
+* The RTSP restreamer forwards source RTP untouched and must know, per
+* packet, whether it is part of a keyframe picture: that is what its keyframe
+* cache collects and what a backlog-latched session resumes on. The
+* depacketizer can only say so about a NAL that COMPLETED, so the fragments of
+* a fragmented IDR before the last one, and a prefix SEI between the parameter
+* sets and the slice, were reported as plain packets: the cache latch closed
+* on them and re-opened on the final fragment, and a backlogged session
+* counted every IRAP slice as a missed keyframe. Here a packet is classified
+* by what it carries ({@link RtpPacketClass}) and the verdict is carried
+* across the whole picture, bounded by the RTP timestamp and marker bit.
+*
+* A parameter-set-only run is not a picture: a camera that stamps SPS/PPS
+* with the previous timestamp still announces ONE keyframe, so the keyframe
+* verdict carries over into the slice that follows instead of starting twice.
+*/
+var RtpAccessUnitTracker = class {
+	timestamp = -1;
+	previousMarker = true;
+	keyframeAu = false;
+	/** The picture in progress has received something other than a parameter set. */
+	pictureSeen = false;
+	classify(packet) {
+		const auStart = this.previousMarker || packet.timestamp !== this.timestamp;
+		if (auStart && this.pictureSeen) this.keyframeAu = false;
+		if (auStart) this.pictureSeen = false;
+		this.timestamp = packet.timestamp;
+		this.previousMarker = packet.marker;
+		const keyframeContent = packet.keyframe || packet.parameterSet;
+		const keyframeAuStart = keyframeContent && !this.keyframeAu;
+		if (keyframeContent) this.keyframeAu = true;
+		if (!packet.parameterSet) this.pictureSeen = true;
+		return {
+			auStart,
+			keyframeAu: this.keyframeAu,
+			keyframeAuStart,
+			parameterSet: packet.parameterSet
+		};
+	}
+	/** A redial re-bases the clock; nothing carries over. */
+	reset() {
+		this.timestamp = -1;
+		this.previousMarker = true;
+		this.keyframeAu = false;
+		this.pictureSeen = false;
+	}
+};
+//#endregion
+//#region src/stream-broker/stream-broker/access-unit-assembler.ts
+/**
+* Groups depacketized NALs into ACCESS UNITS — one per picture.
+*
+* The broker's `EncodedPacket` is one access unit, and every consumer judges it
+* that way: `keyframe` gates where a clip ring widens to, where a late joiner
+* can start, how the pre-roll window is cut; the stats count it as one picture
+* and time the GOP from one `keyframe` to the next. A multi-slice camera (a
+* Hikvision G2 main stream is 3 slices per picture) used to hand each slice —
+* and each prefix SEI — down as its own "frame": 75 input fps on a 25 fps
+* camera, an 8–34 ms "GOP", a clip ring that widened to the LAST IRAP slice
+* (a third of the picture, without its parameter sets), and a prefix SEI that
+* inherited the welded VPS/SPS/PPS instead of the IDR.
+*
+* Boundary rule (RFC 3550 / 6184 / 7798): the RTP marker bit closes the
+* picture it ends — flushed on the spot, so a single-slice stream pays no
+* latency — and a timestamp change closes the one before it, for cameras that
+* never set the marker. Parameter sets are held and welded onto the picture
+* that follows them, so a keyframe access unit is self-contained
+* (VPS/SPS/PPS + IDR) exactly as before; a prefix SEI stays inside its
+* picture and is never a frame of its own.
+*/
+var AccessUnitAssembler = class {
+	onAccessUnit;
+	/** Parameter sets seen since the last picture closed; welded onto the next one. */
+	pendingParamNals = [];
+	/** NALs of the picture in progress (parameter sets first when welded). */
+	pictureNals = [];
+	pictureTimestamp = 0;
+	pictureKeyframe = false;
+	constructor(onAccessUnit) {
+		this.onAccessUnit = onAccessUnit;
+	}
+	push(depacketized) {
+		const { annexB, keyframe, parameterSet, timestamp, marker } = depacketized;
+		if (this.pictureNals.length > 0 && timestamp !== this.pictureTimestamp) this.flush();
+		if (parameterSet) {
+			this.pendingParamNals.push(annexB);
+			return;
+		}
+		if (this.pictureNals.length === 0) {
+			this.pictureTimestamp = timestamp;
+			this.pictureKeyframe = false;
+		}
+		if (this.pendingParamNals.length > 0) {
+			for (const paramNal of this.pendingParamNals) this.pictureNals.push(paramNal);
+			this.pendingParamNals = [];
+			this.pictureKeyframe = true;
+		}
+		this.pictureNals.push(annexB);
+		if (keyframe) this.pictureKeyframe = true;
+		if (marker) this.flush();
+	}
+	/**
+	* Emit the picture in progress, if any. Called on the marker bit, on a
+	* timestamp change, and by the broker when the stream stops or redials so
+	* the last picture of a marker-less stream is not lost.
+	*/
+	flush() {
+		if (this.pictureNals.length === 0) return;
+		const nals = this.pictureNals;
+		const timestamp = this.pictureTimestamp;
+		const keyframe = this.pictureKeyframe;
+		this.pictureNals = [];
+		this.pictureKeyframe = false;
+		const annexB = nals.length === 1 ? nals[0] : Buffer.concat(nals);
+		this.onAccessUnit({
+			annexB,
+			timestamp,
+			keyframe
+		});
+	}
+	/** Drop everything held — a redial re-bases the clock, nothing carries over. */
+	reset() {
+		this.pendingParamNals = [];
+		this.pictureNals = [];
+		this.pictureTimestamp = 0;
+		this.pictureKeyframe = false;
+	}
+};
+//#endregion
 //#region src/stream-broker/rtsp/rtsp-client.ts
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var DEFAULT_KEEPALIVE_INTERVAL_MS = 3e4;
@@ -13153,7 +13375,7 @@ var StreamBroker = class StreamBroker {
 		this.rtspRestreamer.destroy();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.encodedCallbacks.clear();
 		this.audioChunkPlane.dispose();
 	}
@@ -13616,7 +13838,7 @@ var StreamBroker = class StreamBroker {
 		this.reconcilePrestreamWindow();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.rtspRestreamer.resetStreamState();
 		this.totalBytes = 0;
 		this.bytesInWindow = 0;
@@ -14697,8 +14919,9 @@ var StreamBroker = class StreamBroker {
 				} });
 				this._lastNalKeyframe = false;
 				this._lastNalParamSet = false;
-				this.rtpDepacketizer?.processPacket(rtpData);
-				this.rtspRestreamer.pushRtpPassthrough(rtpData, this._lastNalKeyframe, this._lastNalParamSet);
+				const carried = this.rtpDepacketizer?.processPacket(rtpData) ?? null;
+				const auFlags = carried ? this.rtpAuTracker.classify(carried) : null;
+				this.rtspRestreamer.pushRtpPassthrough(rtpData, auFlags?.keyframeAu ?? false, auFlags?.parameterSet ?? false);
 				this.captureRtpForPreBuffer(rtpData);
 				if (this.rtpVideoCallbacks.size > 0) for (const [cb, entry] of this.rtpVideoCallbacks) try {
 					cb(rtpData);
@@ -14894,51 +15117,44 @@ var StreamBroker = class StreamBroker {
 	* RTSP restreamer's pushRtpPassthrough.
 	*/
 	/**
-	* Pending parameter-set NALs (SPS/PPS for H.264, VPS/SPS/PPS for H.265).
-	* Cameras emit these as separate RTP packets before the IDR/IRAP frame.
-	* We buffer them here and prepend to the next VCL NAL so downstream
-	* consumers (WebRTC, prebuffer, restream) receive complete access units
-	* with a single `EncodedPacket` that contains SPS+PPS+IDR together.
+	* Groups the depacketizer's NALs into access units — ONE `EncodedPacket`
+	* per picture, parameter sets welded onto the keyframe picture they
+	* precede. See `access-unit-assembler.ts` for the boundary rule and the
+	* per-NAL emit it replaced.
 	*/
-	pendingParamNals = [];
+	annexBAssembler = new AccessUnitAssembler((accessUnit) => this.emitAccessUnit(accessUnit));
+	/** Access-unit membership of the source RTP packets, for the restreamer's flags. */
+	rtpAuTracker = new RtpAccessUnitTracker();
 	/**
 	* handleDepacketizedNal receives individual NALs from the RTP depacketizer
-	* and emits them as EncodedPackets.
-	*
-	* Parameter-set NALs (SPS/PPS type 7/8 for H.264, VPS/SPS/PPS type 32/33/34
-	* for H.265) are buffered and prepended to the next VCL NAL (slice/IDR).
-	* This guarantees every keyframe EncodedPacket is a self-contained access
-	* unit that a decoder can initialise from — critical for WebRTC (Chrome
-	* can't decode an IDR without preceding SPS/PPS).
+	* and hands them to the access-unit assembler, which emits one
+	* `EncodedPacket` per PICTURE (`emitAccessUnit`) — never per NAL. A
+	* multi-slice IDR, its parameter sets and its prefix SEI are one keyframe
+	* packet; three P slices are one P packet.
 	*
-	* The RTSP restreamer handles its own RTP passthrough separately and is
-	* not affected by this merging.
+	* The RTSP restreamer forwards source RTP separately (`onVideoRtp`) and is
+	* not fed from here.
 	*/
 	handleDepacketizedNal(depacketized) {
-		const { nal, keyframe, parameterSet, timestamp } = depacketized;
+		if (depacketized.keyframe) this._lastNalKeyframe = true;
+		if (depacketized.parameterSet) this._lastNalParamSet = true;
+		this.annexBAssembler.push(depacketized);
+	}
+	/**
+	* One assembled access unit → one `EncodedPacket` for every Annex-B
+	* consumer (prebuffer, clip ring, pipe, WebRTC). A keyframe packet is
+	* self-contained (VPS/SPS/PPS + every IDR slice), which is what a decoder
+	* initialises from and what a clip or a pre-roll window may start at.
+	*/
+	emitAccessUnit(accessUnit) {
 		const codec = this.detectedCodec ?? "h264";
-		if (keyframe) this._lastNalKeyframe = true;
-		if (parameterSet) this._lastNalParamSet = true;
-		const isH264 = codec === "h264";
-		const nalType = isH264 ? nal[0] & 31 : (nal[0] & 126) >> 1;
-		if (isH264 ? nalType === 7 || nalType === 8 : nalType === 32 || nalType === 33 || nalType === 34) {
-			this.pendingParamNals.push(depacketized.annexB);
-			return;
-		}
-		const hadParamSets = this.pendingParamNals.length > 0;
-		let annexBData;
-		if (hadParamSets) {
-			this.pendingParamNals.push(depacketized.annexB);
-			annexBData = Buffer.concat(this.pendingParamNals);
-			this.pendingParamNals = [];
-		} else annexBData = depacketized.annexB;
-		const pts = Math.floor(timestamp / 90);
+		const pts = Math.floor(accessUnit.timestamp / 90);
 		const packet = {
 			type: "video",
-			data: annexBData,
+			data: accessUnit.annexB,
 			pts,
 			dts: pts,
-			keyframe: keyframe || hadParamSets,
+			keyframe: accessUnit.keyframe,
 			codec
 		};
 		this.pushEncodedPacket(packet);
@@ -15342,6 +15558,9 @@ var StreamBroker = class StreamBroker {
 			this.rtpDepacketizer.reset();
 			this.rtpDepacketizer = null;
 		}
+		this.annexBAssembler.flush();
+		this.annexBAssembler.reset();
+		this.rtpAuTracker.reset();
 		if (this.pushRtpFlagDepacketizer) {
 			this.pushRtpFlagDepacketizer.reset();
 			this.pushRtpFlagDepacketizer = null;

package/dist/stream-broker/index.mjs

@@ -3727,7 +3727,12 @@ var RtspRestreamer = class {
 	* Forwarded directly to all connected RTSP sessions — zero re-packetization.
 	*
 	* @param rtpData Complete RTP packet (header + payload)
-	* @param isKeyframe True if this packet is part of a keyframe access unit
+	* @param isKeyframe True if this packet is part of a keyframe ACCESS UNIT —
+	*   judged per picture by the broker's `RtpAccessUnitTracker`: every
+	*   fragment of a fragmented IDR and a prefix SEI inside the picture carry
+	*   it, not only the packet that completed an IRAP NAL. The keyframe cache
+	*   below collects exactly that run, and the transition into it is the
+	*   once-per-picture `keyframeAuStart` the sessions resume and count on.
 	* @param isParameterSet True if this packet contains SPS/PPS/VPS
 	*/
 	pushRtpPassthrough(rtpData, isKeyframe, isParameterSet) {
@@ -3743,14 +3748,14 @@ var RtspRestreamer = class {
 				this.lastKeyframeRtpBytes = 0;
 			}
 		}
+		if (this.collectingKeyframeRtp && !isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
 		if (this.collectingKeyframeRtp) {
 			this.lastKeyframeRtpPackets.push({
 				data: Buffer.from(rtpData),
 				marker: rtpPacket.marker
 			});
 			this.lastKeyframeRtpBytes += rtpData.length;
-			if (!isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
-			else if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
+			if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
 				this.warnCacheCapExceeded("rtp", this.lastKeyframeRtpBytes, this.lastKeyframeRtpPackets.length);
 				this.lastKeyframeRtpPackets = [];
 				this.lastKeyframeRtpBytes = 0;
@@ -3763,17 +3768,16 @@ var RtspRestreamer = class {
 			if (!session.isPlaying()) continue;
 			this.pendingKeyframe.delete(session.getSessionId());
 		}
-		const keyframeAu = isKeyframe || isParameterSet;
 		for (const session of this.sessions.values()) {
 			const sessionId = session.getSessionId();
 			if (this.activeReplays.get(sessionId)?.enqueue({
 				packet: rtpPacket,
 				prime: false,
-				keyframeAuStart: keyframeAu
+				keyframeAuStart
 			})) continue;
 			if (this.pendingKeyframe.has(sessionId)) continue;
 			if (!session.isPlaying()) continue;
-			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAu));
+			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAuStart));
 		}
 	}
 	/**
@@ -10124,6 +10128,16 @@ function allocAnnexBNal(byteLength) {
 	buf[3] = 1;
 	return buf;
 }
+var NO_PAYLOAD_CLASS = {
+	keyframe: false,
+	parameterSet: false
+};
+function isH265IrapType(type) {
+	return type >= H265_NAL_IRAP_MIN && type <= H265_NAL_IRAP_MAX;
+}
+function isH265ParameterSetType(type) {
+	return type === H265_NAL_VPS || type === H265_NAL_SPS || type === H265_NAL_PPS;
+}
 /** Total byte length of the reassembly fragments, without allocating a closure. */
 function totalFragmentBytes(fragments) {
 	let total = 0;
@@ -10169,16 +10183,92 @@ var RtpDepacketizer = class {
 	}
 	/**
 	* Process a raw RTP packet (including 12-byte RTP header).
-	* Emits zero or more complete NAL units via the callback.
+	* Emits zero or more complete NAL units via the callback and returns what
+	* THIS packet carried ({@link RtpPacketClass}) — `null` for a packet too
+	* short to be RTP with a payload.
 	*/
 	processPacket(rtpData) {
-		if (rtpData.length < 12) return;
+		if (rtpData.length < 12) return null;
 		const marker = (rtpData[1] & 128) !== 0;
 		const timestamp = rtpData.readUInt32BE(4);
 		const payload = rtpData.subarray(12);
-		if (payload.length === 0) return;
+		if (payload.length === 0) return null;
+		const carried = this.codec === "h264" ? this.classifyH264Payload(payload) : this.classifyH265Payload(payload);
 		if (this.codec === "h264") this.processH264(payload, timestamp, marker);
 		else this.processH265(payload, timestamp, marker);
+		return {
+			timestamp,
+			marker,
+			keyframe: carried.keyframe,
+			parameterSet: carried.parameterSet
+		};
+	}
+	/** H.264: single NAL by its type; STAP-A by every aggregated type; FU-A by the FU header. */
+	classifyH264Payload(payload) {
+		const nalType = payload[0] & 31;
+		if (nalType === H264_NAL_STAP_A) {
+			let keyframe = false;
+			let parameterSet = false;
+			let offset = 1;
+			while (offset + 2 <= payload.length) {
+				const nalSize = payload.readUInt16BE(offset);
+				offset += 2;
+				if (nalSize === 0 || offset + nalSize > payload.length) break;
+				const type = payload[offset] & 31;
+				keyframe ||= type === H264_NAL_IDR;
+				parameterSet ||= type === H264_NAL_SPS || type === H264_NAL_PPS;
+				offset += nalSize;
+			}
+			return {
+				keyframe,
+				parameterSet
+			};
+		}
+		if (nalType === 28) {
+			if (payload.length < 2) return NO_PAYLOAD_CLASS;
+			return {
+				keyframe: (payload[1] & 31) === H264_NAL_IDR,
+				parameterSet: false
+			};
+		}
+		return {
+			keyframe: nalType === H264_NAL_IDR,
+			parameterSet: nalType === H264_NAL_SPS || nalType === H264_NAL_PPS
+		};
+	}
+	/** H.265: single NAL by its type; AP by every aggregated type; FU by the FU header. */
+	classifyH265Payload(payload) {
+		if (payload.length < 2) return NO_PAYLOAD_CLASS;
+		const nalType = payload[0] >> 1 & 63;
+		if (nalType === H265_NAL_AP) {
+			let keyframe = false;
+			let parameterSet = false;
+			let offset = 2;
+			while (offset + 2 <= payload.length) {
+				const nalSize = payload.readUInt16BE(offset);
+				offset += 2;
+				if (nalSize === 0 || offset + nalSize > payload.length) break;
+				const type = payload[offset] >> 1 & 63;
+				keyframe ||= isH265IrapType(type);
+				parameterSet ||= isH265ParameterSetType(type);
+				offset += nalSize;
+			}
+			return {
+				keyframe,
+				parameterSet
+			};
+		}
+		if (nalType === 49) {
+			if (payload.length < 3) return NO_PAYLOAD_CLASS;
+			return {
+				keyframe: isH265IrapType(payload[2] & 63),
+				parameterSet: false
+			};
+		}
+		return {
+			keyframe: isH265IrapType(nalType),
+			parameterSet: isH265ParameterSetType(nalType)
+		};
 	}
 	processH264(payload, timestamp, marker) {
 		const nalType = payload[0] & 31;
@@ -10324,6 +10414,138 @@ var RtpDepacketizer = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/rtsp/rtp-access-unit-tracker.ts
+/**
+* Tracks access-unit membership across the source RTP packets of ONE stream.
+*
+* The RTSP restreamer forwards source RTP untouched and must know, per
+* packet, whether it is part of a keyframe picture: that is what its keyframe
+* cache collects and what a backlog-latched session resumes on. The
+* depacketizer can only say so about a NAL that COMPLETED, so the fragments of
+* a fragmented IDR before the last one, and a prefix SEI between the parameter
+* sets and the slice, were reported as plain packets: the cache latch closed
+* on them and re-opened on the final fragment, and a backlogged session
+* counted every IRAP slice as a missed keyframe. Here a packet is classified
+* by what it carries ({@link RtpPacketClass}) and the verdict is carried
+* across the whole picture, bounded by the RTP timestamp and marker bit.
+*
+* A parameter-set-only run is not a picture: a camera that stamps SPS/PPS
+* with the previous timestamp still announces ONE keyframe, so the keyframe
+* verdict carries over into the slice that follows instead of starting twice.
+*/
+var RtpAccessUnitTracker = class {
+	timestamp = -1;
+	previousMarker = true;
+	keyframeAu = false;
+	/** The picture in progress has received something other than a parameter set. */
+	pictureSeen = false;
+	classify(packet) {
+		const auStart = this.previousMarker || packet.timestamp !== this.timestamp;
+		if (auStart && this.pictureSeen) this.keyframeAu = false;
+		if (auStart) this.pictureSeen = false;
+		this.timestamp = packet.timestamp;
+		this.previousMarker = packet.marker;
+		const keyframeContent = packet.keyframe || packet.parameterSet;
+		const keyframeAuStart = keyframeContent && !this.keyframeAu;
+		if (keyframeContent) this.keyframeAu = true;
+		if (!packet.parameterSet) this.pictureSeen = true;
+		return {
+			auStart,
+			keyframeAu: this.keyframeAu,
+			keyframeAuStart,
+			parameterSet: packet.parameterSet
+		};
+	}
+	/** A redial re-bases the clock; nothing carries over. */
+	reset() {
+		this.timestamp = -1;
+		this.previousMarker = true;
+		this.keyframeAu = false;
+		this.pictureSeen = false;
+	}
+};
+//#endregion
+//#region src/stream-broker/stream-broker/access-unit-assembler.ts
+/**
+* Groups depacketized NALs into ACCESS UNITS — one per picture.
+*
+* The broker's `EncodedPacket` is one access unit, and every consumer judges it
+* that way: `keyframe` gates where a clip ring widens to, where a late joiner
+* can start, how the pre-roll window is cut; the stats count it as one picture
+* and time the GOP from one `keyframe` to the next. A multi-slice camera (a
+* Hikvision G2 main stream is 3 slices per picture) used to hand each slice —
+* and each prefix SEI — down as its own "frame": 75 input fps on a 25 fps
+* camera, an 8–34 ms "GOP", a clip ring that widened to the LAST IRAP slice
+* (a third of the picture, without its parameter sets), and a prefix SEI that
+* inherited the welded VPS/SPS/PPS instead of the IDR.
+*
+* Boundary rule (RFC 3550 / 6184 / 7798): the RTP marker bit closes the
+* picture it ends — flushed on the spot, so a single-slice stream pays no
+* latency — and a timestamp change closes the one before it, for cameras that
+* never set the marker. Parameter sets are held and welded onto the picture
+* that follows them, so a keyframe access unit is self-contained
+* (VPS/SPS/PPS + IDR) exactly as before; a prefix SEI stays inside its
+* picture and is never a frame of its own.
+*/
+var AccessUnitAssembler = class {
+	onAccessUnit;
+	/** Parameter sets seen since the last picture closed; welded onto the next one. */
+	pendingParamNals = [];
+	/** NALs of the picture in progress (parameter sets first when welded). */
+	pictureNals = [];
+	pictureTimestamp = 0;
+	pictureKeyframe = false;
+	constructor(onAccessUnit) {
+		this.onAccessUnit = onAccessUnit;
+	}
+	push(depacketized) {
+		const { annexB, keyframe, parameterSet, timestamp, marker } = depacketized;
+		if (this.pictureNals.length > 0 && timestamp !== this.pictureTimestamp) this.flush();
+		if (parameterSet) {
+			this.pendingParamNals.push(annexB);
+			return;
+		}
+		if (this.pictureNals.length === 0) {
+			this.pictureTimestamp = timestamp;
+			this.pictureKeyframe = false;
+		}
+		if (this.pendingParamNals.length > 0) {
+			for (const paramNal of this.pendingParamNals) this.pictureNals.push(paramNal);
+			this.pendingParamNals = [];
+			this.pictureKeyframe = true;
+		}
+		this.pictureNals.push(annexB);
+		if (keyframe) this.pictureKeyframe = true;
+		if (marker) this.flush();
+	}
+	/**
+	* Emit the picture in progress, if any. Called on the marker bit, on a
+	* timestamp change, and by the broker when the stream stops or redials so
+	* the last picture of a marker-less stream is not lost.
+	*/
+	flush() {
+		if (this.pictureNals.length === 0) return;
+		const nals = this.pictureNals;
+		const timestamp = this.pictureTimestamp;
+		const keyframe = this.pictureKeyframe;
+		this.pictureNals = [];
+		this.pictureKeyframe = false;
+		const annexB = nals.length === 1 ? nals[0] : Buffer.concat(nals);
+		this.onAccessUnit({
+			annexB,
+			timestamp,
+			keyframe
+		});
+	}
+	/** Drop everything held — a redial re-bases the clock, nothing carries over. */
+	reset() {
+		this.pendingParamNals = [];
+		this.pictureNals = [];
+		this.pictureTimestamp = 0;
+		this.pictureKeyframe = false;
+	}
+};
+//#endregion
 //#region src/stream-broker/rtsp/rtsp-client.ts
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var DEFAULT_KEEPALIVE_INTERVAL_MS = 3e4;
@@ -13149,7 +13371,7 @@ var StreamBroker = class StreamBroker {
 		this.rtspRestreamer.destroy();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.encodedCallbacks.clear();
 		this.audioChunkPlane.dispose();
 	}
@@ -13612,7 +13834,7 @@ var StreamBroker = class StreamBroker {
 		this.reconcilePrestreamWindow();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.rtspRestreamer.resetStreamState();
 		this.totalBytes = 0;
 		this.bytesInWindow = 0;
@@ -14693,8 +14915,9 @@ var StreamBroker = class StreamBroker {
 				} });
 				this._lastNalKeyframe = false;
 				this._lastNalParamSet = false;
-				this.rtpDepacketizer?.processPacket(rtpData);
-				this.rtspRestreamer.pushRtpPassthrough(rtpData, this._lastNalKeyframe, this._lastNalParamSet);
+				const carried = this.rtpDepacketizer?.processPacket(rtpData) ?? null;
+				const auFlags = carried ? this.rtpAuTracker.classify(carried) : null;
+				this.rtspRestreamer.pushRtpPassthrough(rtpData, auFlags?.keyframeAu ?? false, auFlags?.parameterSet ?? false);
 				this.captureRtpForPreBuffer(rtpData);
 				if (this.rtpVideoCallbacks.size > 0) for (const [cb, entry] of this.rtpVideoCallbacks) try {
 					cb(rtpData);
@@ -14890,51 +15113,44 @@ var StreamBroker = class StreamBroker {
 	* RTSP restreamer's pushRtpPassthrough.
 	*/
 	/**
-	* Pending parameter-set NALs (SPS/PPS for H.264, VPS/SPS/PPS for H.265).
-	* Cameras emit these as separate RTP packets before the IDR/IRAP frame.
-	* We buffer them here and prepend to the next VCL NAL so downstream
-	* consumers (WebRTC, prebuffer, restream) receive complete access units
-	* with a single `EncodedPacket` that contains SPS+PPS+IDR together.
+	* Groups the depacketizer's NALs into access units — ONE `EncodedPacket`
+	* per picture, parameter sets welded onto the keyframe picture they
+	* precede. See `access-unit-assembler.ts` for the boundary rule and the
+	* per-NAL emit it replaced.
 	*/
-	pendingParamNals = [];
+	annexBAssembler = new AccessUnitAssembler((accessUnit) => this.emitAccessUnit(accessUnit));
+	/** Access-unit membership of the source RTP packets, for the restreamer's flags. */
+	rtpAuTracker = new RtpAccessUnitTracker();
 	/**
 	* handleDepacketizedNal receives individual NALs from the RTP depacketizer
-	* and emits them as EncodedPackets.
-	*
-	* Parameter-set NALs (SPS/PPS type 7/8 for H.264, VPS/SPS/PPS type 32/33/34
-	* for H.265) are buffered and prepended to the next VCL NAL (slice/IDR).
-	* This guarantees every keyframe EncodedPacket is a self-contained access
-	* unit that a decoder can initialise from — critical for WebRTC (Chrome
-	* can't decode an IDR without preceding SPS/PPS).
+	* and hands them to the access-unit assembler, which emits one
+	* `EncodedPacket` per PICTURE (`emitAccessUnit`) — never per NAL. A
+	* multi-slice IDR, its parameter sets and its prefix SEI are one keyframe
+	* packet; three P slices are one P packet.
 	*
-	* The RTSP restreamer handles its own RTP passthrough separately and is
-	* not affected by this merging.
+	* The RTSP restreamer forwards source RTP separately (`onVideoRtp`) and is
+	* not fed from here.
 	*/
 	handleDepacketizedNal(depacketized) {
-		const { nal, keyframe, parameterSet, timestamp } = depacketized;
+		if (depacketized.keyframe) this._lastNalKeyframe = true;
+		if (depacketized.parameterSet) this._lastNalParamSet = true;
+		this.annexBAssembler.push(depacketized);
+	}
+	/**
+	* One assembled access unit → one `EncodedPacket` for every Annex-B
+	* consumer (prebuffer, clip ring, pipe, WebRTC). A keyframe packet is
+	* self-contained (VPS/SPS/PPS + every IDR slice), which is what a decoder
+	* initialises from and what a clip or a pre-roll window may start at.
+	*/
+	emitAccessUnit(accessUnit) {
 		const codec = this.detectedCodec ?? "h264";
-		if (keyframe) this._lastNalKeyframe = true;
-		if (parameterSet) this._lastNalParamSet = true;
-		const isH264 = codec === "h264";
-		const nalType = isH264 ? nal[0] & 31 : (nal[0] & 126) >> 1;
-		if (isH264 ? nalType === 7 || nalType === 8 : nalType === 32 || nalType === 33 || nalType === 34) {
-			this.pendingParamNals.push(depacketized.annexB);
-			return;
-		}
-		const hadParamSets = this.pendingParamNals.length > 0;
-		let annexBData;
-		if (hadParamSets) {
-			this.pendingParamNals.push(depacketized.annexB);
-			annexBData = Buffer.concat(this.pendingParamNals);
-			this.pendingParamNals = [];
-		} else annexBData = depacketized.annexB;
-		const pts = Math.floor(timestamp / 90);
+		const pts = Math.floor(accessUnit.timestamp / 90);
 		const packet = {
 			type: "video",
-			data: annexBData,
+			data: accessUnit.annexB,
 			pts,
 			dts: pts,
-			keyframe: keyframe || hadParamSets,
+			keyframe: accessUnit.keyframe,
 			codec
 		};
 		this.pushEncodedPacket(packet);
@@ -15338,6 +15554,9 @@ var StreamBroker = class StreamBroker {
 			this.rtpDepacketizer.reset();
 			this.rtpDepacketizer = null;
 		}
+		this.annexBAssembler.flush();
+		this.annexBAssembler.reset();
+		this.rtpAuTracker.reset();
 		if (this.pushRtpFlagDepacketizer) {
 			this.pushRtpFlagDepacketizer.reset();
 			this.pushRtpFlagDepacketizer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.363",
+  "version": "1.2.364",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",