@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/lib/rtp/codec/vp9.js

@@ -0,0 +1,157 @@
+// RTP Payload Format for VP9 Video draft-ietf-payload-vp9-16 https://datatracker.ietf.org/doc/html/draft-ietf-payload-vp9
+import { getBit, paddingByte } from '../../common/index.js';
+//          0 1 2 3 4 5 6 7
+//         +-+-+-+-+-+-+-+-+
+//         |I|P|L|F|B|E|V|Z| (REQUIRED)
+//         +-+-+-+-+-+-+-+-+
+//    I:   |M| PICTURE ID  | (REQUIRED)
+//         +-+-+-+-+-+-+-+-+
+//    M:   | EXTENDED PID  | (RECOMMENDED)
+//         +-+-+-+-+-+-+-+-+
+//    L:   | TID |U| SID |D| (Conditionally RECOMMENDED)
+//         +-+-+-+-+-+-+-+-+                             -\
+//    P,F: | P_DIFF      |N| (Conditionally REQUIRED)    - up to 3 times
+//         +-+-+-+-+-+-+-+-+                             -/
+//    V:   | SS            |
+//         | ..            |
+//         +-+-+-+-+-+-+-+-+
+//          0 1 2 3 4 5 6 7
+//         +-+-+-+-+-+-+-+-+
+//         |I|P|L|F|B|E|V|Z| (REQUIRED)
+//         +-+-+-+-+-+-+-+-+
+//    I:   |M| PICTURE ID  | (RECOMMENDED)
+//         +-+-+-+-+-+-+-+-+
+//    M:   | EXTENDED PID  | (RECOMMENDED)
+//         +-+-+-+-+-+-+-+-+
+//    L:   | TID |U| SID |D| (Conditionally RECOMMENDED)
+//         +-+-+-+-+-+-+-+-+
+//         |   TL0PICIDX   | (Conditionally REQUIRED)
+//         +-+-+-+-+-+-+-+-+
+//    V:   | SS            |
+//         | ..            |
+//         +-+-+-+-+-+-+-+-+
+export class Vp9RtpPayload {
+    constructor() {
+        this.pDiff = [];
+        this.width = [];
+        this.height = [];
+        this.n_g = 0;
+        this.pgT = [];
+        this.pgU = [];
+        this.pgP_Diff = [];
+    }
+    static deSerialize(buf) {
+        const { p, offset } = this.parseRtpPayload(buf);
+        p.payload = buf.subarray(offset);
+        return p;
+    }
+    static parseRtpPayload(buf) {
+        const p = new Vp9RtpPayload();
+        let offset = 0;
+        p.iBit = getBit(buf[offset], 0); // PictureId present .
+        p.pBit = getBit(buf[offset], 1); // Inter-picture predicted.
+        p.lBit = getBit(buf[offset], 2); // Layer indices present.
+        p.fBit = getBit(buf[offset], 3); // Flexible mode.
+        p.bBit = getBit(buf[offset], 4); // Begins frame flag.
+        p.eBit = getBit(buf[offset], 5); // Ends frame flag.
+        p.vBit = getBit(buf[offset], 6); // Scalability structure present.
+        p.zBit = getBit(buf[offset], 7); // Not used for inter-layer prediction
+        offset++;
+        if (p.iBit) {
+            p.m = getBit(buf[offset], 0);
+            if (p.m) {
+                const _7 = paddingByte(getBit(buf[offset], 1, 7));
+                const _8 = paddingByte(buf[offset + 1]);
+                p.pictureId = Number.parseInt(_7 + _8, 2);
+                offset += 2;
+            }
+            else {
+                p.pictureId = getBit(buf[offset], 1, 7);
+                offset++;
+            }
+        }
+        if (p.lBit) {
+            p.tid = getBit(buf[offset], 0, 3);
+            p.u = getBit(buf[offset], 3);
+            p.sid = getBit(buf[offset], 4, 3);
+            p.d = getBit(buf[offset], 7);
+            offset++;
+            if (p.fBit === 0) {
+                p.tl0PicIdx = buf[offset];
+                offset++;
+            }
+        }
+        if (p.fBit && p.pBit) {
+            for (;;) {
+                p.pDiff = [...p.pDiff, getBit(buf[offset], 0, 7)];
+                const n = getBit(buf[offset], 7);
+                offset++;
+                if (n === 0)
+                    break;
+            }
+        }
+        // Scalability structure (SS):
+        //
+        //      +-+-+-+-+-+-+-+-+
+        // V:   | N_S |Y|G|-|-|-|
+        //      +-+-+-+-+-+-+-+-+              -|
+        // Y:   |     WIDTH     | (OPTIONAL)    .
+        //      +               +               .
+        //      |               | (OPTIONAL)    .
+        //      +-+-+-+-+-+-+-+-+               . N_S + 1 times
+        //      |     HEIGHT    | (OPTIONAL)    .
+        //      +               +               .
+        //      |               | (OPTIONAL)    .
+        //      +-+-+-+-+-+-+-+-+              -|
+        // G:   |      N_G      | (OPTIONAL)
+        //      +-+-+-+-+-+-+-+-+                           -|
+        // N_G: |  T  |U| R |-|-| (OPTIONAL)                 .
+        //      +-+-+-+-+-+-+-+-+              -|            . N_G times
+        //      |    P_DIFF     | (OPTIONAL)    . R times    .
+        //      +-+-+-+-+-+-+-+-+              -|           -|
+        //
+        if (p.vBit) {
+            p.n_s = getBit(buf[offset], 0, 3);
+            p.y = getBit(buf[offset], 3);
+            p.g = getBit(buf[offset], 4);
+            offset++;
+            if (p.y) {
+                [...Array(p.n_s + 1)].forEach(() => {
+                    p.width.push(buf.readUInt16BE(offset));
+                    offset += 2;
+                    p.height.push(buf.readUInt16BE(offset));
+                    offset += 2;
+                });
+            }
+            if (p.g) {
+                p.n_g = buf[offset];
+                offset++;
+            }
+            if (p.n_g > 0) {
+                [...Array(p.n_g).keys()].forEach((i) => {
+                    p.pgT.push(getBit(buf[offset], 0, 3));
+                    p.pgU.push(getBit(buf[offset], 3));
+                    const r = getBit(buf[offset], 4, 2);
+                    offset++;
+                    p.pgP_Diff[i] = [];
+                    if (r > 0) {
+                        [...Array(r)].forEach(() => {
+                            p.pgP_Diff[i].push(buf[offset]);
+                            offset++;
+                        });
+                    }
+                });
+            }
+        }
+        return { offset, p };
+    }
+    static isDetectedFinalPacketInSequence(header) {
+        return header.marker;
+    }
+    get isKeyframe() {
+        return !!(!this.pBit && this.bBit && (!this.sid || !this.lBit));
+    }
+    get isPartitionHead() {
+        return this.bBit && (!this.lBit || !this.d);
+    }
+}

package/dist/esm/lib/rtp/const.js

@@ -0,0 +1 @@
+export const MTU = 1200;

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

@@ -0,0 +1,29 @@
+export function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+export function growBufferSize(buf, size) {
+    const glow = Buffer.alloc(size);
+    buf.copy(glow);
+    return glow;
+}
+export function Int(v) {
+    return Number.parseInt(v.toString(), 10);
+}
+export const 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);
+    }
+};
+export function isMedia(buf) {
+    const firstByte = buf[0];
+    return firstByte > 127 && firstByte < 192;
+}

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

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

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

@@ -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/esm/lib/rtp/rtcp/header.js

@@ -0,0 +1,46 @@
+import { BitWriter, bufferReader, bufferWriter, getBit } from '../../common/index.js';
+export const 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            |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+export 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 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 = bufferWriter([1, 1, 2], [v_p_rc.value, this.type, this.length]);
+        return buf;
+    }
+    static deSerialize(buf) {
+        const [v_p_rc, type, length] = bufferReader(buf, [1, 1, 2]);
+        const version = getBit(v_p_rc, 0, 2);
+        const padding = getBit(v_p_rc, 2, 1) > 0;
+        const count = getBit(v_p_rc, 3, 5);
+        return new RtcpHeader({ version, padding, count, type, length });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { bufferReader, bufferWriter } from '../../../common/index.js';
+export 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] = 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 = 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]);
+    }
+}

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

@@ -0,0 +1,35 @@
+import { debug } from '../../imports/common.js';
+import { RtcpHeader } from '../header.js';
+import { FullIntraRequest } from './fullIntraRequest.js';
+import { PictureLossIndication } from './pictureLossIndication.js';
+import { ReceiverEstimatedMaxBitrate } from './remb.js';
+const log = debug('webrtc/rtp/rtcp/psfb/index');
+export class RtcpPayloadSpecificFeedback {
+    static { this.type = 206; }
+    constructor(props = {}) {
+        this.type = RtcpPayloadSpecificFeedback.type;
+        Object.assign(this, props);
+    }
+    serialize() {
+        const payload = this.feedback.serialize();
+        return RtcpHeader.serialize(this.type, this.feedback.count, payload, this.feedback.length);
+    }
+    static deSerialize(data, header) {
+        let feedback;
+        switch (header.count) {
+            case FullIntraRequest.count:
+                feedback = FullIntraRequest.deSerialize(data);
+                break;
+            case PictureLossIndication.count:
+                feedback = PictureLossIndication.deSerialize(data);
+                break;
+            case ReceiverEstimatedMaxBitrate.count:
+                feedback = ReceiverEstimatedMaxBitrate.deSerialize(data);
+                break;
+            default:
+                log('unknown psfb packet', header.count);
+                break;
+        }
+        return new RtcpPayloadSpecificFeedback({ feedback });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { bufferReader, bufferWriter } from '../../../common/index.js';
+export 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] = bufferReader(data, [4, 4]);
+        return new PictureLossIndication({ senderSsrc, mediaSsrc });
+    }
+    serialize() {
+        return bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]);
+    }
+}

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

@@ -0,0 +1,49 @@
+import { BitWriter, bufferReader, bufferWriter, getBit } from '../../../common/index.js';
+export 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] = bufferReader(data, [4, 4, 4, 1, 1]);
+        const brExp = getBit(e_m, 0, 6);
+        const brMantissa = (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: bufferWriter([4], [uniqueID]).toString(),
+            ssrcNum,
+            brExp,
+            brMantissa,
+            ssrcFeedbacks,
+            bitrate
+        });
+    }
+    serialize() {
+        const constant = Buffer.concat([
+            bufferWriter([4, 4], [this.senderSsrc, this.mediaSsrc]),
+            Buffer.from(this.uniqueID),
+            bufferWriter([1], [this.ssrcNum])
+        ]);
+        const writer = new BitWriter(24);
+        writer.set(6, 0, this.brExp).set(18, 6, this.brMantissa);
+        const feedbacks = Buffer.concat(this.ssrcFeedbacks.map((feedback) => bufferWriter([4], [feedback])));
+        const buf = Buffer.concat([
+            constant,
+            bufferWriter([3], [writer.value]),
+            feedbacks
+        ]);
+        this.length = buf.length / 4;
+        return buf;
+    }
+}

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

@@ -0,0 +1,68 @@
+import { bufferReader, bufferWriter } from '../../common/index.js';
+import { RtcpHeader } from './header.js';
+export class RtcpRrPacket {
+    static { this.type = 201; }
+    constructor(props = {}) {
+        this.ssrc = 0;
+        this.reports = [];
+        this.type = RtcpRrPacket.type;
+        Object.assign(this, props);
+    }
+    serialize() {
+        let payload = bufferWriter([4], [this.ssrc]);
+        payload = Buffer.concat([
+            payload,
+            ...this.reports.map((report) => report.serialize())
+        ]);
+        return RtcpHeader.serialize(RtcpRrPacket.type, this.reports.length, payload, Math.floor(payload.length / 4));
+    }
+    static deSerialize(data, count) {
+        const [ssrc] = 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 });
+    }
+}
+export 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 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] = bufferReader(data, [4, 1, 3, 4, 4, 4, 4]);
+        return new RtcpReceiverInfo({
+            ssrc,
+            fractionLost,
+            packetsLost,
+            highestSequence,
+            jitter,
+            lsr,
+            dlsr
+        });
+    }
+}

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

@@ -0,0 +1,53 @@
+import { debug } from '../imports/common.js';
+import { RTCP_HEADER_SIZE, RtcpHeader } from './header.js';
+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';
+const log = debug('webrtc/rtp/rtcp/rtcp');
+export class RtcpPacketConverter {
+    static deSerialize(data) {
+        let pos = 0;
+        const packets = [];
+        while (pos < data.length) {
+            const header = RtcpHeader.deSerialize(data.subarray(pos, pos + RTCP_HEADER_SIZE));
+            pos += 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 RtcpSrPacket.type:
+                        packets.push(RtcpSrPacket.deSerialize(payload, header.count));
+                        break;
+                    case RtcpRrPacket.type:
+                        packets.push(RtcpRrPacket.deSerialize(payload, header.count));
+                        break;
+                    case RtcpSourceDescriptionPacket.type:
+                        packets.push(RtcpSourceDescriptionPacket.deSerialize(payload, header));
+                        break;
+                    case RtcpTransportLayerFeedback.type:
+                        packets.push(RtcpTransportLayerFeedback.deSerialize(payload, header));
+                        break;
+                    case RtcpPayloadSpecificFeedback.type:
+                        packets.push(RtcpPayloadSpecificFeedback.deSerialize(payload, header));
+                        break;
+                    default:
+                        // log("unknown rtcp packet", header.type);
+                        break;
+                }
+            }
+            catch (error) {
+                log('deSerialize RTCP', error);
+            }
+        }
+        return packets;
+    }
+}
+export function isRtcp(buf) {
+    return buf.length >= 2 && buf[1] >= 192 && buf[1] <= 208;
+}

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

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

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

@@ -0,0 +1,31 @@
+import { debug } from '../../imports/common.js';
+import { RtcpTransportLayerFeedbackType } from './const.js';
+import { GenericNack } from './nack.js';
+import { TransportWideCC } from './twcc.js';
+const log = debug('webrtc/rtp/rtcp/rtpfb/index');
+export class RtcpTransportLayerFeedback {
+    static { this.type = 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 GenericNack.count:
+                feedback = GenericNack.deSerialize(data, header);
+                break;
+            case TransportWideCC.count:
+                feedback = TransportWideCC.deSerialize(data, header);
+                break;
+            default:
+                log('unknown rtpfb packet', header.count);
+                break;
+        }
+        return new RtcpTransportLayerFeedback({ feedback, header });
+    }
+}

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

@@ -0,0 +1,73 @@
+import { bufferReader, bufferWriter } from '../../../common/index.js';
+import { RtcpHeader } from '../header.js';
+import { RtcpTransportLayerFeedbackType } from './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):
+export 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 RtcpHeader({
+                type: RtcpTransportLayerFeedbackType,
+                count: this.count,
+                version: 2
+            });
+        }
+    }
+    static deSerialize(data, header) {
+        const [senderSsrc, mediaSourceSsrc] = bufferReader(data, [4, 4]);
+        const lost = [];
+        for (let pos = 8; pos < data.length; pos += 4) {
+            const [pid, blp] = 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 = 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(bufferWriter([2, 2], [headPid, blp]));
+                    headPid = pid;
+                    blp = 0;
+                }
+            });
+            fci.push(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]);
+    }
+}