@netkitty/codec 1.0.0

package/dist/headers/RTCP.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * RTCP — RTP Control Protocol (RFC 3550 §6), the companion control channel to RTP. Rides UDP on
+ * dynamically negotiated ports (classically the RTP media port + 1, or multiplexed onto the media port
+ * with rtcp-mux, RFC 5761), so there is no fixed well-known port; a small set of common defaults is
+ * declared as matchKeys and selection stays strictly port-bucketed (see match()).
+ *
+ * Every RTCP packet begins with a 4-byte common header — Version (2 bits, always 2), Padding (1 bit),
+ * a 5-bit count whose meaning is packet-type-specific (Reception Report Count for SR/RR, Source Count
+ * for SDES/BYE), an 8-bit Packet Type (200 SR, 201 RR, 202 SDES, 203 BYE, 204 APP, 205 RTPFB, 206
+ * PSFB, 207 XR) and a 16-bit Length in 32-bit words minus one (RFC 3550 §6.4.1) — and, for the
+ * report-bearing types, an SSRC of the sender. RTCP packets are transmitted as COMPOUND packets:
+ * several stacked back-to-back in a single UDP datagram (RFC 3550 §6.1).
+ *
+ * This minimal codec structures the FIRST packet's common header (version/padding/count/packetType/
+ * length) plus its SSRC, then keeps that first packet's remaining body verbatim as `body` hex (bounded
+ * by the Length field — packet-type-specific decoding of SR sender info / report blocks / SDES chunks
+ * is a later enrichment), and keeps any further compound packets verbatim as `rest` hex (bounded by
+ * the UDP payload). The Length is honored when supplied (a crafted packet may lie) else derived from
+ * the body; every field is width-clamped so a decoded value always re-encodes. A well-formed datagram
+ * round-trips byte-for-byte.
+ */
+class RTCP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rtcp';
+        this.name = 'RTP Control Protocol';
+        this.nickname = 'RTCP';
+        //RTCP uses dynamically negotiated UDP ports with no fixed well-known port. Like RTP, the common
+        //defaults are declared as port buckets and selection stays STRICTLY port-bucketed — heuristicFallback
+        //is deliberately NOT set, because Version==2 + a Packet Type in 200-207 is a weak signature that
+        //would falsely claim unrelated UDP traffic if run over every datagram. Recognition on other ports is
+        //a "decode as" concern, mirroring RTP.
+        this.matchKeys = ['udpport:5005', 'udpport:5007', 'udpport:5009'];
+        //A leaf header — packet-type-specific body and stacked compound packets are kept verbatim.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RTCP.#schemaCache ??= RTCP.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RTCP pt=${packetType} len=${length}',
+            properties: {
+                //Byte 0 packs Version (bits 0-1), Padding (bit 2) and a 5-bit count (bits 3-7). Each is a
+                //separate field over the same octet window; writeBits read-modify-writes so sequential
+                //encode of the three composes byte 0 correctly.
+                version: {
+                    type: 'integer',
+                    label: 'Version',
+                    minimum: 0,
+                    maximum: 3,
+                    decode: function () {
+                        this.instance.version.setValue(this.readBits(0, 1, 0, 2));
+                    },
+                    encode: function () {
+                        const node = this.instance.version;
+                        let value = node.getValue(2, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 3)
+                            value = 3;
+                        if (value < 0)
+                            value = 0;
+                        node.setValue(value);
+                        this.writeBits(0, 1, 0, 2, value);
+                    }
+                },
+                //Padding flag: when set, the packet ends with padding octets whose last byte is the pad
+                //count (RFC 3550 §6.4.1). The padding bytes themselves live inside `body`/`rest` verbatim.
+                padding: {
+                    type: 'integer',
+                    label: 'Padding',
+                    minimum: 0,
+                    maximum: 1,
+                    decode: function () {
+                        this.instance.padding.setValue(this.readBits(0, 1, 2, 1));
+                    },
+                    encode: function () {
+                        const node = this.instance.padding;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 1)
+                            value = 1;
+                        if (value < 0)
+                            value = 0;
+                        node.setValue(value);
+                        this.writeBits(0, 1, 2, 1, value);
+                    }
+                },
+                //5-bit count: Reception Report Count (SR/RR) or Source Count (SDES/BYE), packet-type
+                //dependent. Kept as a plain integer; its per-type semantics are UI enrichment for later.
+                reportCount: {
+                    type: 'integer',
+                    label: 'Report/Source Count',
+                    minimum: 0,
+                    maximum: 31,
+                    decode: function () {
+                        this.instance.reportCount.setValue(this.readBits(0, 1, 3, 5));
+                    },
+                    encode: function () {
+                        const node = this.instance.reportCount;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 31)
+                            value = 31;
+                        if (value < 0)
+                            value = 0;
+                        node.setValue(value);
+                        this.writeBits(0, 1, 3, 5, value);
+                    }
+                },
+                //Packet Type (200 SR .. 207 XR). A plain uint8 — no hard enum, so an unknown/future type
+                //still decodes and re-encodes (never-throws).
+                packetType: this.fieldUInt('packetType', 1, 1, 'Packet Type'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: function () {
+                        //Length = 32-bit words of the first packet minus one (RFC 3550 §6.4.1). The first
+                        //packet is the 8-byte header+SSRC plus `body`. Honored when supplied (a crafted
+                        //packet may lie); else derived from the body length.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : Math.floor((8 + (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length) / 4) - 1;
+                        if (value < 0)
+                            value = 0;
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.length.setValue(value);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //SSRC of the sender (SR/RR/report-bearing types). Kept verbatim as hex — an identifier the
+                //editor round-trips untouched, no endian ambiguity.
+                ssrc: this.fieldHex('ssrc', 4, 4, 'SSRC'),
+                //The first RTCP packet's remaining body after the 8-byte header+SSRC: SR sender info,
+                //report blocks, SDES chunks, etc. Bounded by the Length field (the first packet ends at
+                //(Length+1)*4 bytes) and the captured bytes, so trailing compound packets are NOT swallowed.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.packet.length - this.startPos;
+                        let firstEnd = (this.instance.length.getValue(0) + 1) * 4;
+                        if (firstEnd < 8)
+                            firstEnd = 8;
+                        if (firstEnd > available)
+                            firstEnd = available;
+                        this.instance.body.setValue(firstEnd > 8 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(8, firstEnd - 8)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(8, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                },
+                //Any further packets in the compound RTCP datagram (RFC 3550 §6.1), kept verbatim. Starts
+                //where the first packet ends ((Length+1)*4) and runs to the end of the UDP payload; a leaf
+                //field, sub-decoding each stacked packet is a later enrichment.
+                rest: {
+                    type: 'string',
+                    label: 'Compound Remainder',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.packet.length - this.startPos;
+                        let firstEnd = (this.instance.length.getValue(0) + 1) * 4;
+                        if (firstEnd < 8)
+                            firstEnd = 8;
+                        if (firstEnd > available)
+                            firstEnd = available;
+                        this.instance.rest.setValue(available > firstEnd ? (0, BufferToHex_1.BufferToHex)(this.readBytes(firstEnd, available - firstEnd)) : '');
+                    },
+                    encode: function () {
+                        const rest = this.instance.rest.getValue('');
+                        if (!rest)
+                            return;
+                        let firstEnd = (this.instance.length.getValue(0) + 1) * 4;
+                        if (firstEnd < 8)
+                            firstEnd = 8;
+                        this.writeBytes(firstEnd, (0, HexToBuffer_1.HexToBuffer)(rest));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Only ever consulted for the declared UDP port buckets (no heuristic fallback). Within a bucket,
+        //guard on the two-bit Version (must be 2) and a Packet Type in the RTCP range 200-207 (RFC 3550,
+        //RFC 4585/4587) so non-RTCP traffic on these ports falls through to raw.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.packet.length - this.startPos < 8)
+            return false;
+        const version = (this.readBytes(0, 1, true)[0] >> 6) & 0x03;
+        if (version !== 2)
+            return false;
+        const packetType = this.readBytes(1, 1, true)[0];
+        return packetType >= 200 && packetType <= 207;
+    }
+}
+exports.RTCP = RTCP;

package/dist/headers/RTP.d.ts

@@ -0,0 +1,33 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RTP — Real-time Transport Protocol (RFC 3550), carried over UDP on application-negotiated (SDP)
+ * dynamic ports. The 12-byte fixed header is: byte 0 = Version(2 bits, always 2) + Padding(P) +
+ * Extension(X) + CSRC Count(CC, 4 bits); byte 1 = Marker(M) + Payload Type(PT, 7 bits); then a 16-bit
+ * Sequence Number, a 32-bit Timestamp and a 32-bit SSRC. It is followed by CC × 4-byte CSRC identifiers,
+ * an optional header extension (present when X=1: a 16-bit profile id + a 16-bit length in 32-bit words +
+ * length×4 bytes of data), and the media payload.
+ *
+ * ⚠️ RTP has no in-band magic — its only signature is the 2-bit Version field (==2), far too weak to
+ * heuristically claim arbitrary UDP traffic (that would swallow every UDP flow). So this codec is
+ * port-bucketed ONLY (the common RTP/AVP default even ports 5004/5006/5008) with NO heuristicFallback,
+ * and its match() still requires Version==2 and the full 12-byte header. Real deployments negotiate the
+ * port via SDP, so an editor should offer an explicit decode-as for other ports rather than any guess.
+ *
+ * The CSRC list, optional extension and payload are parsed generically (identifiers/extension data kept
+ * verbatim as hex, payload bounded by the UDP datagram so a retained FCS/padding is not absorbed). The
+ * CSRC Count is honored-else-derived from the CSRC list; the extension length is honored-else-derived
+ * from the extension data byte length; the payload-type-specific media bytes are a leaf (not sub-decoded).
+ * A well-formed packet round-trips byte-for-byte.
+ */
+export declare class RTP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/RTP.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * RTP — Real-time Transport Protocol (RFC 3550), carried over UDP on application-negotiated (SDP)
+ * dynamic ports. The 12-byte fixed header is: byte 0 = Version(2 bits, always 2) + Padding(P) +
+ * Extension(X) + CSRC Count(CC, 4 bits); byte 1 = Marker(M) + Payload Type(PT, 7 bits); then a 16-bit
+ * Sequence Number, a 32-bit Timestamp and a 32-bit SSRC. It is followed by CC × 4-byte CSRC identifiers,
+ * an optional header extension (present when X=1: a 16-bit profile id + a 16-bit length in 32-bit words +
+ * length×4 bytes of data), and the media payload.
+ *
+ * ⚠️ RTP has no in-band magic — its only signature is the 2-bit Version field (==2), far too weak to
+ * heuristically claim arbitrary UDP traffic (that would swallow every UDP flow). So this codec is
+ * port-bucketed ONLY (the common RTP/AVP default even ports 5004/5006/5008) with NO heuristicFallback,
+ * and its match() still requires Version==2 and the full 12-byte header. Real deployments negotiate the
+ * port via SDP, so an editor should offer an explicit decode-as for other ports rather than any guess.
+ *
+ * The CSRC list, optional extension and payload are parsed generically (identifiers/extension data kept
+ * verbatim as hex, payload bounded by the UDP datagram so a retained FCS/padding is not absorbed). The
+ * CSRC Count is honored-else-derived from the CSRC list; the extension length is honored-else-derived
+ * from the extension data byte length; the payload-type-specific media bytes are a leaf (not sub-decoded).
+ * A well-formed packet round-trips byte-for-byte.
+ */
+class RTP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rtp';
+        this.name = 'Real-time Transport Protocol';
+        this.nickname = 'RTP';
+        //RTP/AVP common default even ports only. RTP has no reliable content magic (Version==2 is a 2-bit
+        //signature), so it is NEVER placed in the heuristic fallback list — matching arbitrary UDP traffic
+        //would swallow every UDP flow. Real ports are negotiated by SDP; an editor should decode-as for them.
+        this.matchKeys = ['udpport:5004', 'udpport:5006', 'udpport:5008'];
+        //A leaf header — payload-type (codec) specific media de-structuring is deferred to a later slice.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RTP.#schemaCache ??= RTP.#buildSchema());
+    }
+    /**
+     * The RTP length (fixed header + CSRC + extension + payload) bounded by the enclosing UDP datagram,
+     * so a lying CC/extension length near the end does not read into a retained FCS/padding. Bounds the
+     * field reads and the match gate.
+     */
+    #available() {
+        let available = this.packet.length - this.startPos;
+        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+            const udpLength = this.prevCodecModule.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < available)
+                available = udpLength - 8;
+        }
+        return available < 0 ? 0 : available;
+    }
+    /** A fixed-width big-endian unsigned bit field within one octet at `byteOffset` (bitOffset 0 = MSB). */
+    static #uintBits(name, byteOffset, bitOffset, bitLength, label) {
+        const maximum = (2 ** bitLength) - 1;
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: maximum,
+            decode: function () {
+                this.instance[name].setValue(this.readBits(byteOffset, 1, bitOffset, bitLength));
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > maximum) {
+                    this.recordError(node.getPath(), `Maximum value is ${maximum}`);
+                    value = maximum;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBits(byteOffset, 1, bitOffset, bitLength, value);
+            }
+        };
+    }
+    /** A single flag bit within one octet at `byteOffset` (bitOffset 0 = MSB). */
+    static #flagBit(name, byteOffset, bitOffset, label) {
+        return {
+            type: 'boolean',
+            label: label,
+            decode: function () {
+                this.instance[name].setValue(!!this.readBits(byteOffset, 1, bitOffset, 1));
+            },
+            encode: function () {
+                const value = !!this.instance[name].getValue();
+                this.instance[name].setValue(value);
+                this.writeBits(byteOffset, 1, bitOffset, 1, value ? 1 : 0);
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RTP pt=${payloadType} seq=${sequenceNumber} ssrc=${ssrc}',
+            properties: {
+                //Byte 0 (MSB first): Version(0-1) Padding(2) Extension(3) CSRC Count(4-7).
+                version: this.#uintBits('version', 0, 0, 2, 'Version'),
+                padding: this.#flagBit('padding', 0, 2, 'Padding'),
+                extension: this.#flagBit('extension', 0, 3, 'Extension'),
+                //CSRC Count: the number of 4-byte CSRC identifiers. Honored when supplied (a crafted
+                //packet may lie), else derived from the CSRC list length; written into byte 0 bits 4-7.
+                csrcCount: {
+                    type: 'integer',
+                    label: 'CSRC Count',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.csrcCount.setValue(this.readBits(0, 1, 4, 4));
+                    },
+                    encode: function () {
+                        const provided = this.instance.csrcCount.getValue();
+                        const csrc = this.instance.csrc.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (Array.isArray(csrc) ? csrc.length : 0);
+                        if (value > 15) {
+                            this.recordError(this.instance.csrcCount.getPath(), 'Maximum value is 15');
+                            value = 15;
+                        }
+                        if (value < 0)
+                            value = 0;
+                        this.instance.csrcCount.setValue(value);
+                        this.writeBits(0, 1, 4, 4, value);
+                    }
+                },
+                //Byte 1 (MSB first): Marker(0) Payload Type(1-7).
+                marker: this.#flagBit('marker', 1, 0, 'Marker'),
+                payloadType: this.#uintBits('payloadType', 1, 1, 7, 'Payload Type'),
+                sequenceNumber: this.fieldUInt('sequenceNumber', 2, 2, 'Sequence Number'),
+                timestamp: this.fieldUInt('timestamp', 4, 4, 'Timestamp'),
+                ssrc: this.fieldUInt('ssrc', 8, 4, 'SSRC'),
+                //CC × 4-byte contributing-source identifiers, kept verbatim as hex. Populated by the
+                //master `body` field (offsets depend on the CC count decoded above).
+                csrc: {
+                    type: 'array',
+                    label: 'CSRC List',
+                    items: {
+                        type: 'string',
+                        label: 'CSRC',
+                        contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                    }
+                },
+                //Optional header extension (RFC 3550 §5.3.1), present only when the Extension (X) flag is
+                //set: a 16-bit profile id, a 16-bit length in 32-bit words, then length×4 bytes of data.
+                //Populated by the master `body` field.
+                extensionHeader: {
+                    type: 'object',
+                    label: 'Header Extension',
+                    properties: {
+                        profile: { type: 'integer', label: 'Profile', minimum: 0, maximum: 65535 },
+                        length: { type: 'integer', label: 'Length (32-bit words)', minimum: 0, maximum: 65535 },
+                        data: { type: 'string', label: 'Data', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                    }
+                },
+                //The media payload, kept verbatim as hex, bounded by the UDP datagram. Payload-type
+                //(codec) specific de-structuring is a leaf — not sub-decoded here.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                },
+                //Master field: the CSRC list, optional extension and payload have flag/count-dependent
+                //offsets, so they are parsed/emitted together here (runs after the fixed fields — property
+                //order). Hidden: it carries no value of its own, only drives the variable-length tail.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    hidden: true,
+                    decode: function () {
+                        const available = this.#available();
+                        //CSRC count clamped to the spec's 0-15 AND to the bytes actually present, so a
+                        //lying count cannot spawn phantom identifiers past the datagram end.
+                        let count = this.instance.csrcCount.getValue(0);
+                        if (count < 0)
+                            count = 0;
+                        if (count > 15)
+                            count = 15;
+                        if (12 + count * 4 > available)
+                            count = Math.floor((available - 12) / 4);
+                        if (count < 0)
+                            count = 0;
+                        let offset = 12;
+                        const csrc = [];
+                        for (let i = 0; i < count; i++) {
+                            csrc.push((0, BufferToHex_1.BufferToHex)(this.readBytes(offset, 4)));
+                            offset += 4;
+                        }
+                        this.instance.csrc.setValue(csrc);
+                        const hasExtension = !!this.instance.extension.getValue();
+                        if (hasExtension && offset + 4 <= available) {
+                            const profile = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset, 2));
+                            const words = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset + 2, 2));
+                            offset += 4;
+                            let dataBytes = words * 4;
+                            if (offset + dataBytes > available)
+                                dataBytes = available - offset;
+                            if (dataBytes < 0)
+                                dataBytes = 0;
+                            const data = dataBytes > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(offset, dataBytes)) : '';
+                            offset += dataBytes;
+                            this.instance.extensionHeader.profile.setValue(profile);
+                            this.instance.extensionHeader.length.setValue(words);
+                            this.instance.extensionHeader.data.setValue(data);
+                        }
+                        const payloadBytes = available - offset > 0 ? available - offset : 0;
+                        this.instance.payload.setValue(payloadBytes > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(offset, payloadBytes)) : '');
+                    },
+                    encode: function () {
+                        let offset = 12;
+                        const csrc = this.instance.csrc.getValue();
+                        if (Array.isArray(csrc)) {
+                            csrc.forEach((entry) => {
+                                //Normalize each identifier to exactly 4 bytes so the tail stays aligned
+                                //(a decoded entry is 8 hex chars → copied whole; a crafted one is padded/
+                                //truncated).
+                                const source = (0, HexToBuffer_1.HexToBuffer)(typeof entry === 'string' && entry ? entry : '00000000');
+                                const four = Buffer.alloc(4);
+                                source.copy(four, 0, 0, 4);
+                                this.writeBytes(offset, four);
+                                offset += 4;
+                            });
+                        }
+                        //Emit the extension only when the X flag is set AND an extension header was
+                        //actually captured on decode. A malformed packet with X=1 but too few trailing
+                        //bytes decodes without an extensionHeader (the decode gates on availability); if
+                        //encode emitted one solely from the X bit it would synthesize 4 zero bytes the
+                        //wire never had, breaking byte-perfect. Honoring the captured extension keeps them
+                        //symmetric.
+                        const extHeader = this.instance.extensionHeader.getValue();
+                        const hasExtension = !!this.instance.extension.getValue() && extHeader !== undefined && extHeader !== null;
+                        if (hasExtension) {
+                            let profile = this.instance.extensionHeader.profile.getValue(0);
+                            if (profile > 65535)
+                                profile = 65535;
+                            if (profile < 0)
+                                profile = 0;
+                            const data = this.instance.extensionHeader.data.getValue('');
+                            const dataBuffer = (0, HexToBuffer_1.HexToBuffer)(data);
+                            //Length honored when supplied (a crafted packet may lie), else derived from
+                            //the data byte length (in 32-bit words).
+                            const providedLength = this.instance.extensionHeader.length.getValue();
+                            let words = (providedLength !== undefined && providedLength !== null)
+                                ? providedLength
+                                : Math.ceil(dataBuffer.length / 4);
+                            if (words > 65535)
+                                words = 65535;
+                            if (words < 0)
+                                words = 0;
+                            this.instance.extensionHeader.profile.setValue(profile);
+                            this.instance.extensionHeader.length.setValue(words);
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt16ToBuffer)(profile));
+                            this.writeBytes(offset + 2, (0, NumberToBuffer_1.UInt16ToBuffer)(words));
+                            offset += 4;
+                            if (dataBuffer.length) {
+                                this.writeBytes(offset, dataBuffer);
+                                offset += dataBuffer.length;
+                            }
+                        }
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(offset, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //RTP rides on UDP (one of the default RTP/AVP ports). Require the full 12-byte fixed header within
+        //the datagram and the Version==2 signature (bits 7:6 of byte 0) so a non-RTP datagram on the port
+        //falls through to raw rather than claiming an un-decodable layer.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.#available() < 12)
+            return false;
+        return this.readBits(0, 1, 0, 2) === 2;
+    }
+}
+exports.RTP = RTP;

package/dist/headers/RTPS.d.ts

@@ -0,0 +1,33 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RTPS — the OMG DDSI-RTPS wire protocol (Real-Time Publish-Subscribe) that carries DDS traffic for
+ * industrial IoT / robotics. It rides UDP on dynamically negotiated ports (the well-known 7400-range
+ * discovery ports are only defaults), so selection is by content signature, not port: every RTPS
+ * message opens with a 20-byte header — the 4-byte magic 'RTPS' (0x52545053), a 2-byte protocol
+ * version, a 2-byte vendorId, and a 12-byte guidPrefix — followed by a sequence of submessages.
+ *
+ * Each submessage is a 4-byte submessage header — submessageId(1), flags(1), submessageLength(2) —
+ * then `submessageLength` body octets. The single most important quirk: the low bit of the flags octet
+ * is the EndiannessFlag, and it governs the byte order of THAT submessage's submessageLength field
+ * (little-endian when set, big-endian when clear). A submessageLength of 0 is legal for the final
+ * submessage and means "the rest of the message"; it is honored verbatim so the frame round-trips.
+ *
+ * The submessage bodies (DATA's serialized payload, ACKNACK bitmaps, INFO_TS timestamps, …) are cross-
+ * message, QoS- and type-dependent state, so they are kept verbatim as hex (byte-perfect) rather than
+ * sub-decoded. The whole message is bounded by the UDP payload (the parent UDP Length when present),
+ * and every submessageLength is honored on encode (a crafted message may lie), else derived from the
+ * body. A well-formed message round-trips byte-for-byte.
+ */
+export declare class RTPS extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}