@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/rtp/helper.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timer = void 0;
+exports.enumerate = enumerate;
+exports.growBufferSize = growBufferSize;
+exports.Int = Int;
+exports.isMedia = isMedia;
+function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+function growBufferSize(buf, size) {
+    const glow = Buffer.alloc(size);
+    buf.copy(glow);
+    return glow;
+}
+function Int(v) {
+    return Number.parseInt(v.toString(), 10);
+}
+exports.timer = {
+    setTimeout: (...args) => {
+        const id = setTimeout(...args);
+        return () => clearTimeout(id);
+    },
+    setInterval: (...args) => {
+        const id = setInterval(() => {
+            args[0]();
+        }, 
+        //@ts-expect-error The arguments after the callback (the delay) are spread as given
+        ...args.slice(1));
+        return () => clearInterval(id);
+    }
+};
+function isMedia(buf) {
+    const firstByte = buf[0];
+    return firstByte > 127 && firstByte < 192;
+}

package/dist/cjs/lib/rtp/imports/common.d.ts

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/cjs/lib/rtp/imports/common.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../common/index.js"), exports);

package/dist/cjs/lib/rtp/index.d.ts

@@ -0,0 +1,25 @@
+export * from './srtp/const.js';
+export * from '../common/index.js';
+export * from './codec/index.js';
+export * from './helper.js';
+export * from './rtcp/header.js';
+export * from './rtcp/psfb/index.js';
+export * from './rtcp/psfb/pictureLossIndication.js';
+export * from './rtcp/psfb/remb.js';
+export * from './rtcp/rr.js';
+export * from './rtcp/rtcp.js';
+export * from './rtcp/rtpfb/index.js';
+export * from './rtcp/rtpfb/nack.js';
+export * from './rtcp/rtpfb/twcc.js';
+export * from './rtcp/sdes.js';
+export * from './rtcp/sr.js';
+export * from './rtp/headerExtension.js';
+export * from './rtp/red/encoder.js';
+export * from './rtp/red/handler.js';
+export * from './rtp/red/packet.js';
+export * from './rtp/rtp.js';
+export * from './rtp/rtx.js';
+export * from './srtp/srtcp.js';
+export * from './srtp/srtp.js';
+export * from './srtp/error.js';
+export * from './util.js';

package/dist/cjs/lib/rtp/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./srtp/const.js"), exports);
+__exportStar(require("../common/index.js"), exports);
+__exportStar(require("./codec/index.js"), exports);
+__exportStar(require("./helper.js"), exports);
+__exportStar(require("./rtcp/header.js"), exports);
+__exportStar(require("./rtcp/psfb/index.js"), exports);
+__exportStar(require("./rtcp/psfb/pictureLossIndication.js"), exports);
+__exportStar(require("./rtcp/psfb/remb.js"), exports);
+__exportStar(require("./rtcp/rr.js"), exports);
+__exportStar(require("./rtcp/rtcp.js"), exports);
+__exportStar(require("./rtcp/rtpfb/index.js"), exports);
+__exportStar(require("./rtcp/rtpfb/nack.js"), exports);
+__exportStar(require("./rtcp/rtpfb/twcc.js"), exports);
+__exportStar(require("./rtcp/sdes.js"), exports);
+__exportStar(require("./rtcp/sr.js"), exports);
+__exportStar(require("./rtp/headerExtension.js"), exports);
+__exportStar(require("./rtp/red/encoder.js"), exports);
+__exportStar(require("./rtp/red/handler.js"), exports);
+__exportStar(require("./rtp/red/packet.js"), exports);
+__exportStar(require("./rtp/rtp.js"), exports);
+__exportStar(require("./rtp/rtx.js"), exports);
+__exportStar(require("./srtp/srtcp.js"), exports);
+__exportStar(require("./srtp/srtp.js"), exports);
+__exportStar(require("./srtp/error.js"), exports);
+__exportStar(require("./util.js"), exports);

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

@@ -0,0 +1,13 @@
+export declare const RTCP_HEADER_SIZE = 4;
+export declare class RtcpHeader {
+    version: number;
+    padding: boolean;
+    count: number;
+    type: number;
+    /**このパケットの長さは、ヘッダーと任意のパディングを含む32ビットワードから 1を引いたものである */
+    length: number;
+    constructor(props?: Partial<RtcpHeader>);
+    static serialize(type: number, count: number, payload: Buffer, length: number): Buffer<ArrayBuffer>;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(buf: Buffer): RtcpHeader;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpHeader = exports.RTCP_HEADER_SIZE = void 0;
+const index_js_1 = require("../../common/index.js");
+exports.RTCP_HEADER_SIZE = 4;
+/*
+ *  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
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * |V=2|P|    RC   |      PT       |             length            |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+class RtcpHeader {
+    constructor(props = {}) {
+        this.version = 2;
+        this.padding = false;
+        this.count = 0;
+        this.type = 0;
+        /**このパケットの長さは、ヘッダーと任意のパディングを含む32ビットワードから 1を引いたものである */
+        this.length = 0;
+        Object.assign(this, props);
+    }
+    static serialize(type, count, payload, length) {
+        const header = new RtcpHeader({
+            type,
+            count,
+            version: 2,
+            length
+        });
+        const buf = header.serialize();
+        return Buffer.concat([buf, payload]);
+    }
+    serialize() {
+        const v_p_rc = new index_js_1.BitWriter(8);
+        v_p_rc.set(2, 0, this.version);
+        if (this.padding)
+            v_p_rc.set(1, 2, 1);
+        v_p_rc.set(5, 3, this.count);
+        const buf = (0, index_js_1.bufferWriter)([1, 1, 2], [v_p_rc.value, this.type, this.length]);
+        return buf;
+    }
+    static deSerialize(buf) {
+        const [v_p_rc, type, length] = (0, index_js_1.bufferReader)(buf, [1, 1, 2]);
+        const version = (0, index_js_1.getBit)(v_p_rc, 0, 2);
+        const padding = (0, index_js_1.getBit)(v_p_rc, 2, 1) > 0;
+        const count = (0, index_js_1.getBit)(v_p_rc, 3, 5);
+        return new RtcpHeader({ version, padding, count, type, length });
+    }
+}
+exports.RtcpHeader = RtcpHeader;

package/dist/cjs/lib/rtp/rtcp/psfb/fullIntraRequest.d.ts

@@ -0,0 +1,16 @@
+type firEntry = {
+    ssrc: number;
+    sequenceNumber: number;
+};
+export declare class FullIntraRequest {
+    static count: number;
+    count: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    fir: firEntry[];
+    constructor(props?: Partial<FullIntraRequest>);
+    get length(): number;
+    static deSerialize(data: Buffer): FullIntraRequest;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export {};

package/dist/cjs/lib/rtp/rtcp/psfb/fullIntraRequest.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullIntraRequest = void 0;
+const index_js_1 = require("../../../common/index.js");
+class FullIntraRequest {
+    static { this.count = 4; }
+    constructor(props = {}) {
+        this.count = FullIntraRequest.count;
+        this.fir = [];
+        Object.assign(this, props);
+    }
+    //The words after the header, as the length of RTCP counts them
+    get length() {
+        return this.serialize().length / 4;
+    }
+    static deSerialize(data) {
+        const [senderSsrc, mediaSsrc] = (0, index_js_1.bufferReader)(data, [4, 4]);
+        const fir = [];
+        for (let i = 8; i < data.length; i += 8) {
+            fir.push({ ssrc: data.readUInt32BE(i), sequenceNumber: data[i + 4] });
+        }
+        return new FullIntraRequest({ senderSsrc, mediaSsrc, fir });
+    }
+    serialize() {
+        const ssrcs = (0, index_js_1.bufferWriter)([4, 4], [this.senderSsrc, this.mediaSsrc]);
+        const fir = Buffer.alloc(this.fir.length * 8);
+        this.fir.forEach(({ ssrc, sequenceNumber }, i) => {
+            fir.writeUInt32BE(ssrc, i * 8);
+            fir[i * 8 + 4] = sequenceNumber;
+        });
+        return Buffer.concat([ssrcs, fir]);
+    }
+}
+exports.FullIntraRequest = FullIntraRequest;

package/dist/cjs/lib/rtp/rtcp/psfb/index.d.ts

@@ -0,0 +1,14 @@
+import { RtcpHeader } from '../header.js';
+import { FullIntraRequest } from './fullIntraRequest.js';
+import { PictureLossIndication } from './pictureLossIndication.js';
+import { ReceiverEstimatedMaxBitrate } from './remb.js';
+type Feedback = FullIntraRequest | PictureLossIndication | ReceiverEstimatedMaxBitrate;
+export declare class RtcpPayloadSpecificFeedback {
+    static readonly type = 206;
+    readonly type = 206;
+    feedback: Feedback;
+    constructor(props?: Partial<RtcpPayloadSpecificFeedback>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, header: RtcpHeader): RtcpPayloadSpecificFeedback;
+}
+export {};

package/dist/cjs/lib/rtp/rtcp/psfb/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpPayloadSpecificFeedback = void 0;
+const common_js_1 = require("../../imports/common.js");
+const header_js_1 = require("../header.js");
+const fullIntraRequest_js_1 = require("./fullIntraRequest.js");
+const pictureLossIndication_js_1 = require("./pictureLossIndication.js");
+const remb_js_1 = require("./remb.js");
+const log = (0, common_js_1.debug)('webrtc/rtp/rtcp/psfb/index');
+class RtcpPayloadSpecificFeedback {
+    static { this.type = 206; }
+    constructor(props = {}) {
+        this.type = RtcpPayloadSpecificFeedback.type;
+        Object.assign(this, props);
+    }
+    serialize() {
+        const payload = this.feedback.serialize();
+        return header_js_1.RtcpHeader.serialize(this.type, this.feedback.count, payload, this.feedback.length);
+    }
+    static deSerialize(data, header) {
+        let feedback;
+        switch (header.count) {
+            case fullIntraRequest_js_1.FullIntraRequest.count:
+                feedback = fullIntraRequest_js_1.FullIntraRequest.deSerialize(data);
+                break;
+            case pictureLossIndication_js_1.PictureLossIndication.count:
+                feedback = pictureLossIndication_js_1.PictureLossIndication.deSerialize(data);
+                break;
+            case remb_js_1.ReceiverEstimatedMaxBitrate.count:
+                feedback = remb_js_1.ReceiverEstimatedMaxBitrate.deSerialize(data);
+                break;
+            default:
+                log('unknown psfb packet', header.count);
+                break;
+        }
+        return new RtcpPayloadSpecificFeedback({ feedback });
+    }
+}
+exports.RtcpPayloadSpecificFeedback = RtcpPayloadSpecificFeedback;

package/dist/cjs/lib/rtp/rtcp/psfb/pictureLossIndication.d.ts

@@ -0,0 +1,10 @@
+export declare class PictureLossIndication {
+    static count: number;
+    count: number;
+    length: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    constructor(props?: Partial<PictureLossIndication>);
+    static deSerialize(data: Buffer): PictureLossIndication;
+    serialize(): Buffer<ArrayBuffer>;
+}

package/dist/cjs/lib/rtp/rtcp/psfb/pictureLossIndication.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PictureLossIndication = void 0;
+const index_js_1 = require("../../../common/index.js");
+class PictureLossIndication {
+    static { this.count = 1; }
+    constructor(props = {}) {
+        this.count = PictureLossIndication.count;
+        this.length = 2;
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        const [senderSsrc, mediaSsrc] = (0, index_js_1.bufferReader)(data, [4, 4]);
+        return new PictureLossIndication({ senderSsrc, mediaSsrc });
+    }
+    serialize() {
+        return (0, index_js_1.bufferWriter)([4, 4], [this.senderSsrc, this.mediaSsrc]);
+    }
+}
+exports.PictureLossIndication = PictureLossIndication;

package/dist/cjs/lib/rtp/rtcp/psfb/remb.d.ts

@@ -0,0 +1,16 @@
+export declare class ReceiverEstimatedMaxBitrate {
+    static count: number;
+    length: number;
+    count: number;
+    senderSsrc: number;
+    mediaSsrc: number;
+    readonly uniqueID: string;
+    ssrcNum: number;
+    brExp: number;
+    brMantissa: number;
+    bitrate: bigint;
+    ssrcFeedbacks: number[];
+    constructor(props?: Partial<ReceiverEstimatedMaxBitrate>);
+    static deSerialize(data: Buffer): ReceiverEstimatedMaxBitrate;
+    serialize(): Buffer<ArrayBuffer>;
+}

package/dist/cjs/lib/rtp/rtcp/psfb/remb.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiverEstimatedMaxBitrate = void 0;
+const index_js_1 = require("../../../common/index.js");
+class ReceiverEstimatedMaxBitrate {
+    static { this.count = 15; }
+    constructor(props = {}) {
+        this.count = ReceiverEstimatedMaxBitrate.count;
+        this.uniqueID = 'REMB';
+        this.ssrcNum = 0;
+        this.ssrcFeedbacks = [];
+        Object.assign(this, props);
+    }
+    static deSerialize(data) {
+        const [senderSsrc, mediaSsrc, uniqueID, ssrcNum, e_m] = (0, index_js_1.bufferReader)(data, [4, 4, 4, 1, 1]);
+        const brExp = (0, index_js_1.getBit)(e_m, 0, 6);
+        const brMantissa = ((0, index_js_1.getBit)(e_m, 6, 2) << 16) + (data[14] << 8) + data[15];
+        const bitrate = brExp > 46 ? 18446744073709551615n : BigInt(brMantissa) << BigInt(brExp);
+        const ssrcFeedbacks = [];
+        for (let i = 16; i < data.length; i += 4) {
+            const feedback = data.slice(i).readUIntBE(0, 4);
+            ssrcFeedbacks.push(feedback);
+        }
+        return new ReceiverEstimatedMaxBitrate({
+            senderSsrc,
+            mediaSsrc,
+            uniqueID: (0, index_js_1.bufferWriter)([4], [uniqueID]).toString(),
+            ssrcNum,
+            brExp,
+            brMantissa,
+            ssrcFeedbacks,
+            bitrate
+        });
+    }
+    serialize() {
+        const constant = Buffer.concat([
+            (0, index_js_1.bufferWriter)([4, 4], [this.senderSsrc, this.mediaSsrc]),
+            Buffer.from(this.uniqueID),
+            (0, index_js_1.bufferWriter)([1], [this.ssrcNum])
+        ]);
+        const writer = new index_js_1.BitWriter(24);
+        writer.set(6, 0, this.brExp).set(18, 6, this.brMantissa);
+        const feedbacks = Buffer.concat(this.ssrcFeedbacks.map((feedback) => (0, index_js_1.bufferWriter)([4], [feedback])));
+        const buf = Buffer.concat([
+            constant,
+            (0, index_js_1.bufferWriter)([3], [writer.value]),
+            feedbacks
+        ]);
+        this.length = buf.length / 4;
+        return buf;
+    }
+}
+exports.ReceiverEstimatedMaxBitrate = ReceiverEstimatedMaxBitrate;

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

@@ -0,0 +1,32 @@
+export declare class RtcpRrPacket {
+    ssrc: number;
+    reports: RtcpReceiverInfo[];
+    static readonly type = 201;
+    readonly type = 201;
+    constructor(props?: Partial<RtcpRrPacket>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, count: number): RtcpRrPacket;
+}
+export declare class RtcpReceiverInfo {
+    ssrc: number;
+    fractionLost: number;
+    packetsLost: number;
+    highestSequence: number;
+    jitter: number;
+    /**last SR */
+    lsr: number;
+    /**delay since last SR */
+    dlsr: number;
+    constructor(props?: Partial<RtcpReceiverInfo>);
+    toJSON(): {
+        ssrc: number;
+        fractionLost: number;
+        packetsLost: number;
+        highestSequence: number;
+        jitter: number;
+        lsr: number;
+        dlsr: number;
+    };
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer): RtcpReceiverInfo;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpReceiverInfo = exports.RtcpRrPacket = void 0;
+const index_js_1 = require("../../common/index.js");
+const header_js_1 = require("./header.js");
+class RtcpRrPacket {
+    static { this.type = 201; }
+    constructor(props = {}) {
+        this.ssrc = 0;
+        this.reports = [];
+        this.type = RtcpRrPacket.type;
+        Object.assign(this, props);
+    }
+    serialize() {
+        let payload = (0, index_js_1.bufferWriter)([4], [this.ssrc]);
+        payload = Buffer.concat([
+            payload,
+            ...this.reports.map((report) => report.serialize())
+        ]);
+        return header_js_1.RtcpHeader.serialize(RtcpRrPacket.type, this.reports.length, payload, Math.floor(payload.length / 4));
+    }
+    static deSerialize(data, count) {
+        const [ssrc] = (0, index_js_1.bufferReader)(data, [4]);
+        let pos = 4;
+        const reports = [];
+        for (let _ = 0; _ < count; _++) {
+            reports.push(RtcpReceiverInfo.deSerialize(data.slice(pos, pos + 24)));
+            pos += 24;
+        }
+        return new RtcpRrPacket({ ssrc, reports });
+    }
+}
+exports.RtcpRrPacket = RtcpRrPacket;
+class RtcpReceiverInfo {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+    toJSON() {
+        return {
+            ssrc: this.ssrc,
+            fractionLost: this.fractionLost,
+            packetsLost: this.packetsLost,
+            highestSequence: this.highestSequence,
+            jitter: this.jitter,
+            lsr: this.lsr,
+            dlsr: this.dlsr
+        };
+    }
+    serialize() {
+        return (0, index_js_1.bufferWriter)([4, 1, 3, 4, 4, 4, 4], [
+            this.ssrc,
+            this.fractionLost,
+            this.packetsLost,
+            this.highestSequence,
+            this.jitter,
+            this.lsr,
+            this.dlsr
+        ]);
+    }
+    static deSerialize(data) {
+        const [ssrc, fractionLost, packetsLost, highestSequence, jitter, lsr, dlsr] = (0, index_js_1.bufferReader)(data, [4, 1, 3, 4, 4, 4, 4]);
+        return new RtcpReceiverInfo({
+            ssrc,
+            fractionLost,
+            packetsLost,
+            highestSequence,
+            jitter,
+            lsr,
+            dlsr
+        });
+    }
+}
+exports.RtcpReceiverInfo = RtcpReceiverInfo;

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

@@ -0,0 +1,10 @@
+import { RtcpPayloadSpecificFeedback } from './psfb/index.js';
+import { RtcpRrPacket } from './rr.js';
+import { RtcpTransportLayerFeedback } from './rtpfb/index.js';
+import { RtcpSourceDescriptionPacket } from './sdes.js';
+import { RtcpSrPacket } from './sr.js';
+export type RtcpPacket = RtcpRrPacket | RtcpSrPacket | RtcpPayloadSpecificFeedback | RtcpSourceDescriptionPacket | RtcpTransportLayerFeedback;
+export declare class RtcpPacketConverter {
+    static deSerialize(data: Buffer): RtcpPacket[];
+}
+export declare function isRtcp(buf: Buffer): boolean;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpPacketConverter = void 0;
+exports.isRtcp = isRtcp;
+const common_js_1 = require("../imports/common.js");
+const header_js_1 = require("./header.js");
+const index_js_1 = require("./psfb/index.js");
+const rr_js_1 = require("./rr.js");
+const index_js_2 = require("./rtpfb/index.js");
+const sdes_js_1 = require("./sdes.js");
+const sr_js_1 = require("./sr.js");
+const log = (0, common_js_1.debug)('webrtc/rtp/rtcp/rtcp');
+class RtcpPacketConverter {
+    static deSerialize(data) {
+        let pos = 0;
+        const packets = [];
+        while (pos < data.length) {
+            const header = header_js_1.RtcpHeader.deSerialize(data.subarray(pos, pos + header_js_1.RTCP_HEADER_SIZE));
+            pos += header_js_1.RTCP_HEADER_SIZE;
+            //The payload of this packet only: the padding is counted by its own last byte
+            let payload = data.subarray(pos, pos + header.length * 4);
+            pos += header.length * 4;
+            if (header.padding) {
+                payload = payload.subarray(0, payload.length - payload.subarray(-1)[0]);
+            }
+            try {
+                switch (header.type) {
+                    case sr_js_1.RtcpSrPacket.type:
+                        packets.push(sr_js_1.RtcpSrPacket.deSerialize(payload, header.count));
+                        break;
+                    case rr_js_1.RtcpRrPacket.type:
+                        packets.push(rr_js_1.RtcpRrPacket.deSerialize(payload, header.count));
+                        break;
+                    case sdes_js_1.RtcpSourceDescriptionPacket.type:
+                        packets.push(sdes_js_1.RtcpSourceDescriptionPacket.deSerialize(payload, header));
+                        break;
+                    case index_js_2.RtcpTransportLayerFeedback.type:
+                        packets.push(index_js_2.RtcpTransportLayerFeedback.deSerialize(payload, header));
+                        break;
+                    case index_js_1.RtcpPayloadSpecificFeedback.type:
+                        packets.push(index_js_1.RtcpPayloadSpecificFeedback.deSerialize(payload, header));
+                        break;
+                    default:
+                        // log("unknown rtcp packet", header.type);
+                        break;
+                }
+            }
+            catch (error) {
+                log('deSerialize RTCP', error);
+            }
+        }
+        return packets;
+    }
+}
+exports.RtcpPacketConverter = RtcpPacketConverter;
+function isRtcp(buf) {
+    return buf.length >= 2 && buf[1] >= 192 && buf[1] <= 208;
+}

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

@@ -0,0 +1 @@
+export declare const RtcpTransportLayerFeedbackType = 205;

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpTransportLayerFeedbackType = void 0;
+exports.RtcpTransportLayerFeedbackType = 205;

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

@@ -0,0 +1,14 @@
+import type { RtcpHeader } from '../header.js';
+import { GenericNack } from './nack.js';
+import { TransportWideCC } from './twcc.js';
+type Feedback = GenericNack | TransportWideCC;
+export declare class RtcpTransportLayerFeedback {
+    static readonly type = 205;
+    readonly type = 205;
+    feedback: Feedback;
+    header: RtcpHeader;
+    constructor(props?: Partial<RtcpTransportLayerFeedback>);
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(data: Buffer, header: RtcpHeader): RtcpTransportLayerFeedback;
+}
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcpTransportLayerFeedback = void 0;
+const common_js_1 = require("../../imports/common.js");
+const const_js_1 = require("./const.js");
+const nack_js_1 = require("./nack.js");
+const twcc_js_1 = require("./twcc.js");
+const log = (0, common_js_1.debug)('webrtc/rtp/rtcp/rtpfb/index');
+class RtcpTransportLayerFeedback {
+    static { this.type = const_js_1.RtcpTransportLayerFeedbackType; }
+    constructor(props = {}) {
+        this.type = RtcpTransportLayerFeedback.type;
+        Object.assign(this, props);
+    }
+    serialize() {
+        const payload = this.feedback.serialize();
+        return payload;
+    }
+    static deSerialize(data, header) {
+        let feedback;
+        switch (header.count) {
+            case nack_js_1.GenericNack.count:
+                feedback = nack_js_1.GenericNack.deSerialize(data, header);
+                break;
+            case twcc_js_1.TransportWideCC.count:
+                feedback = twcc_js_1.TransportWideCC.deSerialize(data, header);
+                break;
+            default:
+                log('unknown rtpfb packet', header.count);
+                break;
+        }
+        return new RtcpTransportLayerFeedback({ feedback, header });
+    }
+}
+exports.RtcpTransportLayerFeedback = RtcpTransportLayerFeedback;

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

@@ -0,0 +1,17 @@
+import { RtcpHeader } from '../header.js';
+export declare class GenericNack {
+    static count: number;
+    readonly count: number;
+    header: RtcpHeader;
+    senderSsrc: number;
+    mediaSourceSsrc: number;
+    lost: number[];
+    toJSON(): {
+        lost: number[];
+        senderSsrc: number;
+        mediaSourceSsrc: number;
+    };
+    constructor(props?: Partial<GenericNack>);
+    static deSerialize(data: Buffer, header: RtcpHeader): GenericNack;
+    serialize(): Buffer<ArrayBuffer>;
+}