@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/rtp/rtcp/rtpfb/nack.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericNack = void 0;
+const index_js_1 = require("../../../common/index.js");
+const header_js_1 = require("../header.js");
+const const_js_1 = require("./const.js");
+// 0                   1                   2                   3
+// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |            PID                |             BLP               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// Packet ID (PID)
+// bitmask of following lost packets (BLP):
+class GenericNack {
+    static { this.count = 1; }
+    toJSON() {
+        return {
+            lost: this.lost,
+            senderSsrc: this.senderSsrc,
+            mediaSourceSsrc: this.mediaSourceSsrc
+        };
+    }
+    constructor(props = {}) {
+        this.count = GenericNack.count;
+        this.lost = [];
+        Object.assign(this, props);
+        if (!this.header) {
+            this.header = new header_js_1.RtcpHeader({
+                type: const_js_1.RtcpTransportLayerFeedbackType,
+                count: this.count,
+                version: 2
+            });
+        }
+    }
+    static deSerialize(data, header) {
+        const [senderSsrc, mediaSourceSsrc] = (0, index_js_1.bufferReader)(data, [4, 4]);
+        const lost = [];
+        for (let pos = 8; pos < data.length; pos += 4) {
+            const [pid, blp] = (0, index_js_1.bufferReader)(data.subarray(pos), [2, 2]);
+            lost.push(pid);
+            for (let diff = 0; diff < 16; diff++) {
+                if ((blp >> diff) & 1) {
+                    lost.push(pid + diff + 1);
+                }
+            }
+        }
+        return new GenericNack({
+            header,
+            senderSsrc,
+            mediaSourceSsrc,
+            lost
+        });
+    }
+    serialize() {
+        const ssrcPair = (0, index_js_1.bufferWriter)([4, 4], [this.senderSsrc, this.mediaSourceSsrc]);
+        const fci = [];
+        if (this.lost.length > 0) {
+            let headPid = this.lost[0], blp = 0;
+            this.lost.slice(1).forEach((pid) => {
+                const diff = pid - headPid - 1;
+                if (diff >= 0 && diff < 16) {
+                    blp |= 1 << diff;
+                }
+                else {
+                    fci.push((0, index_js_1.bufferWriter)([2, 2], [headPid, blp]));
+                    headPid = pid;
+                    blp = 0;
+                }
+            });
+            fci.push((0, index_js_1.bufferWriter)([2, 2], [headPid, blp]));
+        }
+        const buf = Buffer.concat([ssrcPair, Buffer.concat(fci)]);
+        this.header.length = buf.length / 4;
+        return Buffer.concat([this.header.serialize(), buf]);
+    }
+}
+exports.GenericNack = GenericNack;

package/dist/cjs/lib/rtp/rtcp/rtpfb/twcc.d.ts

@@ -0,0 +1,71 @@
+import { RtcpHeader } from '../header.js';
+export declare class TransportWideCC {
+    static count: number;
+    count: number;
+    length: number;
+    senderSsrc: number;
+    mediaSourceSsrc: number;
+    baseSequenceNumber: number;
+    packetStatusCount: number;
+    /** 24bit multiples of 64ms */
+    referenceTime: number;
+    fbPktCount: number;
+    packetChunks: (RunLengthChunk | StatusVectorChunk)[];
+    recvDeltas: RecvDelta[];
+    header: RtcpHeader;
+    constructor(props?: Partial<TransportWideCC>);
+    static deSerialize(data: Buffer, header: RtcpHeader): TransportWideCC;
+    serialize(): Buffer<ArrayBuffer>;
+    /**
+     * The packets reported, in the order of their sequence numbers: whether each was received, and when (in
+     * milliseconds, on the clock of the receiver)
+     */
+    get packetResults(): PacketResult[];
+}
+export declare class RunLengthChunk {
+    type: PacketChunk.TypeTCCRunLengthChunk;
+    packetStatus: PacketStatus;
+    /** 13bit */
+    runLength: number;
+    constructor(props?: Partial<RunLengthChunk>);
+    static deSerialize(data: Buffer): RunLengthChunk;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class StatusVectorChunk {
+    type: number;
+    symbolSize: number;
+    symbolList: number[];
+    constructor(props?: Partial<StatusVectorChunk>);
+    static deSerialize(data: Buffer): StatusVectorChunk;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class RecvDelta {
+    /**optional (If undefined, it will be set automatically.)*/
+    type?: PacketStatus.TypeTCCPacketReceivedSmallDelta | PacketStatus.TypeTCCPacketReceivedLargeDelta;
+    /**micro sec */
+    delta: number;
+    constructor(props?: Partial<RecvDelta>);
+    static deSerialize(data: Buffer): RecvDelta;
+    deSerialize(data: Buffer): void;
+    parsed: boolean;
+    parseDelta(): void;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare enum PacketChunk {
+    TypeTCCRunLengthChunk = 0,
+    TypeTCCStatusVectorChunk = 1,
+    packetStatusChunkLength = 2
+}
+export declare enum PacketStatus {
+    TypeTCCPacketNotReceived = 0,
+    TypeTCCPacketReceivedSmallDelta = 1,
+    TypeTCCPacketReceivedLargeDelta = 2,
+    TypeTCCPacketReceivedWithoutDelta = 3
+}
+export declare class PacketResult {
+    sequenceNumber: number;
+    delta: number;
+    received: boolean;
+    receivedAtMs: number;
+    constructor(props: Partial<PacketResult>);
+}

package/dist/cjs/lib/rtp/rtcp/rtpfb/twcc.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketResult = exports.PacketStatus = exports.PacketChunk = exports.RecvDelta = exports.StatusVectorChunk = exports.RunLengthChunk = exports.TransportWideCC = void 0;
+const common_js_1 = require("../../imports/common.js");
+const header_js_1 = require("../header.js");
+const log = (0, common_js_1.debug)('webrtc/rtp/rtcp/rtpfb/twcc');
+/* RTP Extensions for Transport-wide Congestion Control
+ * draft-holmer-rmcat-transport-wide-cc-extensions-01
+
+   0               1               2               3
+   0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |V=2|P|  FMT=15 |    PT=205     |           length              |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                     SSRC of packet sender                     |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                      SSRC of media source                     |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |      base sequence number     |      packet status count      |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |                 reference time                | fb pkt. count |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |          packet chunk         |         packet chunk          |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  .                                                               .
+  .                                                               .
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |         packet chunk          |  recv delta   |  recv delta   |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  .                                                               .
+  .                                                               .
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  |           recv delta          |  recv delta   | zero padding  |
+  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+class TransportWideCC {
+    static { this.count = 15; }
+    constructor(props = {}) {
+        this.count = TransportWideCC.count;
+        this.length = 2;
+        this.packetChunks = [];
+        this.recvDeltas = [];
+        Object.assign(this, props);
+        if (!this.header) {
+            this.header = new header_js_1.RtcpHeader({
+                type: 205,
+                count: this.count,
+                version: 2
+            });
+        }
+    }
+    static deSerialize(data, header) {
+        const [senderSsrc, mediaSsrc, baseSequenceNumber, packetStatusCount, referenceTime, fbPktCount] = (0, common_js_1.bufferReader)(data, [4, 4, 2, 2, 3, 1]);
+        const packetChunks = [];
+        const recvDeltas = [];
+        let packetStatusPos = 16;
+        for (let processedPacketNum = 0; processedPacketNum < packetStatusCount;) {
+            const type = (0, common_js_1.getBit)(data.slice(packetStatusPos, packetStatusPos + 1)[0], 0, 1);
+            let iPacketStatus;
+            switch (type) {
+                case PacketChunk.TypeTCCRunLengthChunk:
+                    {
+                        const packetStatus = RunLengthChunk.deSerialize(data.slice(packetStatusPos, packetStatusPos + 2));
+                        iPacketStatus = packetStatus;
+                        const packetNumberToProcess = Math.min(packetStatusCount - processedPacketNum, packetStatus.runLength);
+                        if (packetStatus.packetStatus ===
+                            PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                            packetStatus.packetStatus ===
+                                PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                            for (let _ = 0; _ < packetNumberToProcess; _++) {
+                                recvDeltas.push(new RecvDelta({ type: packetStatus.packetStatus }));
+                            }
+                        }
+                        processedPacketNum += packetNumberToProcess;
+                    }
+                    break;
+                case PacketChunk.TypeTCCStatusVectorChunk:
+                    {
+                        const packetStatus = StatusVectorChunk.deSerialize(data.slice(packetStatusPos, packetStatusPos + 2));
+                        iPacketStatus = packetStatus;
+                        if (packetStatus.symbolSize === 0) {
+                            packetStatus.symbolList.forEach((v) => {
+                                if (v === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+                                    recvDeltas.push(new RecvDelta({
+                                        type: PacketStatus.TypeTCCPacketReceivedSmallDelta
+                                    }));
+                                }
+                            });
+                        }
+                        if (packetStatus.symbolSize === 1) {
+                            packetStatus.symbolList.forEach((v) => {
+                                if (v === PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                                    v === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                                    recvDeltas.push(new RecvDelta({
+                                        type: v
+                                    }));
+                                }
+                            });
+                        }
+                        processedPacketNum += packetStatus.symbolList.length;
+                    }
+                    break;
+            }
+            if (!iPacketStatus)
+                throw new Error();
+            packetStatusPos += 2;
+            packetChunks.push(iPacketStatus);
+        }
+        let recvDeltaPos = packetStatusPos;
+        recvDeltas.forEach((delta) => {
+            if (delta.type === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+                delta.deSerialize(data.slice(recvDeltaPos, recvDeltaPos + 1));
+                recvDeltaPos++;
+            }
+            if (delta.type === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                delta.deSerialize(data.slice(recvDeltaPos, recvDeltaPos + 2));
+                recvDeltaPos += 2;
+            }
+        });
+        return new TransportWideCC({
+            senderSsrc,
+            mediaSourceSsrc: mediaSsrc,
+            baseSequenceNumber,
+            packetStatusCount,
+            referenceTime,
+            fbPktCount,
+            recvDeltas,
+            packetChunks,
+            header
+        });
+    }
+    serialize() {
+        const constBuf = (0, common_js_1.bufferWriter)([4, 4, 2, 2, 3, 1], [
+            this.senderSsrc,
+            this.mediaSourceSsrc,
+            this.baseSequenceNumber,
+            this.packetStatusCount,
+            this.referenceTime,
+            this.fbPktCount
+        ]);
+        const chunks = Buffer.concat(this.packetChunks.map((chunk) => chunk.serialize()));
+        const deltas = Buffer.concat(this.recvDeltas
+            .map((delta) => {
+            try {
+                return delta.serialize();
+            }
+            catch (error) {
+                log(error?.message);
+                return undefined;
+            }
+        })
+            .filter((v) => v));
+        const buf = Buffer.concat([constBuf, chunks, deltas]);
+        //Padded to 32 bits, the padding flag set only then: the receiver takes the last byte for the length of the padding
+        const rest = buf.length % 4;
+        this.header.padding = rest !== 0;
+        if (rest !== 0) {
+            const padding = Buffer.alloc(4 - rest);
+            padding[padding.length - 1] = padding.length;
+            this.header.length = (buf.length + padding.length) / 4;
+            return Buffer.concat([this.header.serialize(), buf, padding]);
+        }
+        this.header.length = buf.length / 4;
+        return Buffer.concat([this.header.serialize(), buf]);
+    }
+    /**
+     * The packets reported, in the order of their sequence numbers: whether each was received, and when (in
+     * milliseconds, on the clock of the receiver)
+     */
+    get packetResults() {
+        const statuses = [];
+        for (const chunk of this.packetChunks) {
+            if (chunk instanceof RunLengthChunk) {
+                for (let index = 0; index < chunk.runLength; index++)
+                    statuses.push(chunk.packetStatus);
+            }
+            else {
+                statuses.push(...chunk.symbolList);
+            }
+        }
+        //The last status vector may go past the packets reported
+        if (statuses.length > this.packetStatusCount)
+            statuses.length = this.packetStatusCount;
+        const results = [];
+        //In microseconds, from the reference time (in multiples of 64 ms)
+        let receivedAt = this.referenceTime * 64000;
+        let deltaIndex = 0;
+        statuses.forEach((status, index) => {
+            const result = new PacketResult({ sequenceNumber: (this.baseSequenceNumber + index) & 0xffff });
+            if (status === PacketStatus.TypeTCCPacketReceivedSmallDelta ||
+                status === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+                const recvDelta = this.recvDeltas[deltaIndex++];
+                if (recvDelta) {
+                    receivedAt += recvDelta.delta;
+                    result.received = true;
+                    result.delta = recvDelta.delta;
+                    result.receivedAtMs = receivedAt / 1000;
+                }
+            }
+            results.push(result);
+        });
+        return results;
+    }
+}
+exports.TransportWideCC = TransportWideCC;
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |T| S |       Run Length        |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+class RunLengthChunk {
+    constructor(props = {}) {
+        Object.assign(this, props);
+        this.type = PacketChunk.TypeTCCRunLengthChunk;
+    }
+    static deSerialize(data) {
+        const packetStatus = (0, common_js_1.getBit)(data[0], 1, 2);
+        const runLength = ((0, common_js_1.getBit)(data[0], 3, 5) << 8) + data[1];
+        return new RunLengthChunk({ type: 0, packetStatus, runLength });
+    }
+    serialize() {
+        const buf = new common_js_1.BitWriter2(16)
+            .set(0)
+            .set(this.packetStatus, 2)
+            .set(this.runLength, 13).buffer;
+        return buf;
+    }
+}
+exports.RunLengthChunk = RunLengthChunk;
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |T|S|       symbol list         |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+class StatusVectorChunk {
+    constructor(props = {}) {
+        this.symbolList = [];
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        const type = PacketChunk.TypeTCCStatusVectorChunk;
+        let symbolSize = (0, common_js_1.getBit)(data[0], 1, 1);
+        const symbolList = [];
+        function range(n, cb) {
+            for (let i = 0; i < n; i++) {
+                cb(i);
+            }
+        }
+        switch (symbolSize) {
+            case 0:
+                range(6, (i) => symbolList.push((0, common_js_1.getBit)(data[0], 2 + i, 1)));
+                range(8, (i) => symbolList.push((0, common_js_1.getBit)(data[1], i, 1)));
+                break;
+            case 1:
+                range(3, (i) => symbolList.push((0, common_js_1.getBit)(data[0], 2 + i * 2, 2)));
+                range(4, (i) => symbolList.push((0, common_js_1.getBit)(data[1], i * 2, 2)));
+                break;
+            default:
+                symbolSize = ((0, common_js_1.getBit)(data[0], 2, 6) << 8) + data[1];
+        }
+        return new StatusVectorChunk({ type, symbolSize, symbolList });
+    }
+    serialize() {
+        const buf = Buffer.alloc(2);
+        const writer = new common_js_1.BitWriter2(16).set(1).set(this.symbolSize);
+        const bits = this.symbolSize === 0 ? 1 : 2;
+        this.symbolList.forEach((v) => {
+            writer.set(v, bits);
+        });
+        buf.writeUInt16BE(writer.value);
+        return buf;
+    }
+}
+exports.StatusVectorChunk = StatusVectorChunk;
+class RecvDelta {
+    constructor(props = {}) {
+        this.parsed = false; // todo refactor
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        let type;
+        let delta;
+        if (data.length === 1) {
+            type = PacketStatus.TypeTCCPacketReceivedSmallDelta;
+            delta = 250 * data[0];
+        }
+        else if (data.length === 2) {
+            type = PacketStatus.TypeTCCPacketReceivedLargeDelta;
+            delta = 250 * data.readInt16BE();
+        }
+        if (type === undefined || delta === undefined)
+            throw new Error();
+        return new RecvDelta({ type, delta });
+    }
+    deSerialize(data) {
+        const res = RecvDelta.deSerialize(data);
+        this.delta = res.delta;
+    }
+    parseDelta() {
+        this.delta = Math.floor(this.delta / 250);
+        if (this.delta < 0 || this.delta > 255) {
+            if (this.delta > 32767)
+                this.delta = 32767; // maxInt16
+            if (this.delta < -32768)
+                this.delta = -32768; // minInt16
+            if (!this.type)
+                this.type = PacketStatus.TypeTCCPacketReceivedLargeDelta;
+        }
+        else {
+            if (!this.type)
+                this.type = PacketStatus.TypeTCCPacketReceivedSmallDelta;
+        }
+        this.parsed = true;
+    }
+    serialize() {
+        if (!this.parsed)
+            this.parseDelta();
+        if (this.type === PacketStatus.TypeTCCPacketReceivedSmallDelta) {
+            const buf = Buffer.alloc(1);
+            buf.writeUInt8(this.delta);
+            return buf;
+        }
+        else if (this.type === PacketStatus.TypeTCCPacketReceivedLargeDelta) {
+            const buf = Buffer.alloc(2);
+            buf.writeInt16BE(this.delta);
+            return buf;
+        }
+        throw new Error('errDeltaExceedLimit ' + this.delta + ' ' + this.type);
+    }
+}
+exports.RecvDelta = RecvDelta;
+var PacketChunk;
+(function (PacketChunk) {
+    PacketChunk[PacketChunk["TypeTCCRunLengthChunk"] = 0] = "TypeTCCRunLengthChunk";
+    PacketChunk[PacketChunk["TypeTCCStatusVectorChunk"] = 1] = "TypeTCCStatusVectorChunk";
+    PacketChunk[PacketChunk["packetStatusChunkLength"] = 2] = "packetStatusChunkLength";
+})(PacketChunk || (exports.PacketChunk = PacketChunk = {}));
+var PacketStatus;
+(function (PacketStatus) {
+    PacketStatus[PacketStatus["TypeTCCPacketNotReceived"] = 0] = "TypeTCCPacketNotReceived";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedSmallDelta"] = 1] = "TypeTCCPacketReceivedSmallDelta";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedLargeDelta"] = 2] = "TypeTCCPacketReceivedLargeDelta";
+    PacketStatus[PacketStatus["TypeTCCPacketReceivedWithoutDelta"] = 3] = "TypeTCCPacketReceivedWithoutDelta";
+})(PacketStatus || (exports.PacketStatus = PacketStatus = {}));
+class PacketResult {
+    constructor(props) {
+        this.sequenceNumber = 0;
+        this.delta = 0;
+        this.received = false;
+        this.receivedAtMs = 0;
+        Object.assign(this, props);
+    }
+}
+exports.PacketResult = PacketResult;

package/dist/cjs/lib/rtp/rtcp/sdes.d.ts

@@ -0,0 +1,26 @@
+import { RtcpHeader } from './header.js';
+export declare class RtcpSourceDescriptionPacket {
+    static readonly type = 202;
+    readonly type = 202;
+    chunks: SourceDescriptionChunk[];
+    constructor(props: Partial<RtcpSourceDescriptionPacket>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(payload: Buffer, _header: RtcpHeader): RtcpSourceDescriptionPacket;
+}
+export declare class SourceDescriptionChunk {
+    source: number;
+    items: SourceDescriptionItem[];
+    constructor(props?: Partial<SourceDescriptionChunk>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): SourceDescriptionChunk;
+}
+export declare class SourceDescriptionItem {
+    type: number;
+    text: string;
+    constructor(props: Partial<SourceDescriptionItem>);
+    get length(): number;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): SourceDescriptionItem;
+}

package/dist/cjs/lib/rtp/rtcp/sdes.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionItem = exports.SourceDescriptionChunk = exports.RtcpSourceDescriptionPacket = void 0;
+const index_js_1 = require("../../common/index.js");
+const header_js_1 = require("./header.js");
+class RtcpSourceDescriptionPacket {
+    static { this.type = 202; }
+    constructor(props) {
+        this.type = RtcpSourceDescriptionPacket.type;
+        this.chunks = [];
+        Object.assign(this, props);
+    }
+    get length() {
+        let length = 0;
+        this.chunks.forEach((chunk) => (length += chunk.length));
+        return length;
+    }
+    serialize() {
+        let payload = Buffer.concat(this.chunks.map((chunk) => chunk.serialize()));
+        while (payload.length % 4)
+            payload = Buffer.concat([payload, Buffer.from([0])]);
+        return header_js_1.RtcpHeader.serialize(this.type, this.chunks.length, payload, payload.length / 4);
+    }
+    static deSerialize(payload, _header) {
+        const chunks = [];
+        for (let i = 0; i < payload.length;) {
+            const chunk = SourceDescriptionChunk.deSerialize(payload.slice(i));
+            chunks.push(chunk);
+            i += chunk.length;
+        }
+        return new RtcpSourceDescriptionPacket({ chunks });
+    }
+}
+exports.RtcpSourceDescriptionPacket = RtcpSourceDescriptionPacket;
+class SourceDescriptionChunk {
+    constructor(props = {}) {
+        this.items = [];
+        Object.assign(this, props);
+    }
+    get length() {
+        let length = 4;
+        this.items.forEach((item) => (length += item.length));
+        length += 1;
+        length += getPadding(length);
+        return length;
+    }
+    serialize() {
+        const data = Buffer.concat([
+            (0, index_js_1.bufferWriter)([4], [this.source]),
+            Buffer.concat(this.items.map((item) => item.serialize()))
+        ]);
+        const res = Buffer.concat([data, Buffer.alloc(getPadding(data.length))]);
+        return res;
+    }
+    static deSerialize(data) {
+        const source = data.readUInt32BE();
+        const items = [];
+        for (let i = 4; i < data.length;) {
+            const type = data[i];
+            if (type === 0)
+                break;
+            const item = SourceDescriptionItem.deSerialize(data.slice(i));
+            items.push(item);
+            i += item.length;
+        }
+        return new SourceDescriptionChunk({ source, items });
+    }
+}
+exports.SourceDescriptionChunk = SourceDescriptionChunk;
+class SourceDescriptionItem {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+    get length() {
+        return 1 + 1 + Buffer.from(this.text).length;
+    }
+    serialize() {
+        const text = Buffer.from(this.text);
+        return Buffer.concat([
+            (0, index_js_1.bufferWriter)([1, 1], [this.type, text.length]),
+            text
+        ]);
+    }
+    static deSerialize(data) {
+        const type = data[0];
+        const octetCount = data[1];
+        const text = data.slice(2, 2 + octetCount).toString();
+        return new SourceDescriptionItem({ type, text });
+    }
+}
+exports.SourceDescriptionItem = SourceDescriptionItem;
+function getPadding(len) {
+    if (len % 4 == 0) {
+        return 0;
+    }
+    return 4 - (len % 4);
+}

package/dist/cjs/lib/rtp/rtcp/sr.d.ts

@@ -0,0 +1,41 @@
+import { RtcpReceiverInfo } from './rr.js';
+export declare class RtcpSrPacket {
+    ssrc: number;
+    senderInfo: RtcpSenderInfo;
+    reports: RtcpReceiverInfo[];
+    static readonly type = 200;
+    readonly type = 200;
+    constructor(props: Pick<RtcpSrPacket, 'senderInfo'> & Partial<RtcpSrPacket>);
+    toJSON(): {
+        ssrc: number;
+        senderInfo: {
+            ntpTimestamp: number;
+            rtpTimestamp: number;
+        };
+        reports: {
+            ssrc: number;
+            fractionLost: number;
+            packetsLost: number;
+            highestSequence: number;
+            jitter: number;
+            lsr: number;
+            dlsr: number;
+        }[];
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(payload: Buffer, count: number): RtcpSrPacket;
+}
+export declare class RtcpSenderInfo {
+    ntpTimestamp: bigint;
+    rtpTimestamp: number;
+    packetCount: number;
+    octetCount: number;
+    constructor(props?: Partial<RtcpSenderInfo>);
+    toJSON(): {
+        ntpTimestamp: number;
+        rtpTimestamp: number;
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): RtcpSenderInfo;
+}
+export declare const ntpTime2Sec: (ntp: bigint) => number;