@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/rtp/codec/h264.js

@@ -0,0 +1,122 @@
+"use strict";
+// RFC 6184 - RTP Payload Format for H.264 Video
+// pion/rtp
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NalUnitType = exports.H264RtpPayload = void 0;
+const index_js_1 = require("../../common/index.js");
+// FU indicator octet
+// +---------------+
+// |0|1|2|3|4|5|6|7|
+// +-+-+-+-+-+-+-+-+
+// |F|NRI|  Type   |
+// +---------------+
+// FU header
+// +---------------+
+// |0|1|2|3|4|5|6|7|
+// +-+-+-+-+-+-+-+-+
+// |S|E|R|  Type   |
+// +---------------+
+// NAL Unit Type     Content of NAL Unit              NRI (binary)
+// ----------------------------------------------------------------
+//  1              non-IDR coded slice                         10
+//  2              Coded slice data partition A                10
+//  3              Coded slice data partition B                01
+//  4              Coded slice data partition C                01
+// Payload Packet    Single NAL    Non-Interleaved    Interleaved
+// Type    Type      Unit Mode           Mode             Mode
+// -------------------------------------------------------------
+// 0      reserved      ig               ig               ig
+// 1-23   NAL unit     yes              yes               no
+// 24     STAP-A        no              yes               no
+// 25     STAP-B        no               no              yes
+// 26     MTAP16        no               no              yes
+// 27     MTAP24        no               no              yes
+// 28     FU-A          no              yes              yes
+// 29     FU-B          no               no              yes
+// 30-31  reserved      ig               ig               ig
+class H264RtpPayload {
+    static deSerialize(buf, fragment) {
+        const h264 = new H264RtpPayload();
+        let offset = 0;
+        const naluHeader = buf[offset];
+        h264.f = (0, index_js_1.getBit)(naluHeader, 0);
+        h264.nri = (0, index_js_1.getBit)(naluHeader, 1, 2);
+        h264.nalUnitType = (0, index_js_1.getBit)(naluHeader, 3, 5);
+        offset++;
+        h264.s = (0, index_js_1.getBit)(buf[offset], 0);
+        h264.e = (0, index_js_1.getBit)(buf[offset], 1);
+        h264.r = (0, index_js_1.getBit)(buf[offset], 2);
+        h264.nalUnitPayloadType = (0, index_js_1.getBit)(buf[offset], 3, 5);
+        offset++;
+        // デフォルトでは packetization-mode=0
+        // packetization-mode=0だとSingle NAL Unit Packetしか来ない
+        // https://datatracker.ietf.org/doc/html/rfc6184#section-6.2
+        // Single NAL Unit Packet
+        if (0 < h264.nalUnitType && h264.nalUnitType < exports.NalUnitType.stap_a) {
+            h264.payload = this.packaging(buf);
+        }
+        // Single-time aggregation packet
+        else if (h264.nalUnitType === exports.NalUnitType.stap_a) {
+            let offset = stap_aHeaderSize;
+            let result = Buffer.alloc(0);
+            while (offset < buf.length) {
+                const naluSize = buf.readUInt16BE(offset);
+                offset += stap_aNALULengthSize;
+                result = Buffer.concat([
+                    result,
+                    this.packaging(buf.subarray(offset, offset + naluSize))
+                ]);
+                offset += naluSize;
+            }
+            h264.payload = result;
+        }
+        // Fragmentation Units
+        else if (h264.nalUnitType === exports.NalUnitType.fu_a) {
+            if (!fragment) {
+                fragment = Buffer.alloc(0);
+            }
+            const fu = buf.subarray(offset);
+            h264.fragment = Buffer.concat([fragment, fu]);
+            if (h264.e) {
+                const bitStream = new index_js_1.BitStream(Buffer.alloc(1))
+                    .writeBits(1, 0)
+                    .writeBits(2, h264.nri)
+                    .writeBits(5, h264.nalUnitPayloadType);
+                const nalu = Buffer.concat([bitStream.uint8Array, h264.fragment]);
+                h264.fragment = undefined;
+                h264.payload = this.packaging(nalu);
+            }
+        }
+        return h264;
+    }
+    static packaging(buf) {
+        return Buffer.concat([annex_bNALUStartCode, buf]);
+    }
+    static isDetectedFinalPacketInSequence(header) {
+        return header.marker;
+    }
+    get isKeyframe() {
+        return (this.nalUnitType === exports.NalUnitType.idrSlice ||
+            this.nalUnitPayloadType === exports.NalUnitType.idrSlice);
+    }
+    get isPartitionHead() {
+        if (this.nalUnitType === exports.NalUnitType.fu_a ||
+            this.nalUnitType === exports.NalUnitType.fu_b) {
+            return this.s !== 0;
+        }
+        return true;
+    }
+}
+exports.H264RtpPayload = H264RtpPayload;
+exports.NalUnitType = {
+    idrSlice: 5,
+    stap_a: 24,
+    stap_b: 25,
+    mtap16: 26,
+    mtap24: 27,
+    fu_a: 28,
+    fu_b: 29
+};
+const annex_bNALUStartCode = Buffer.from([0x00, 0x00, 0x00, 0x01]);
+const stap_aHeaderSize = 1;
+const stap_aNALULengthSize = 2;

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

@@ -0,0 +1,16 @@
+import type { RtpPacket } from '../rtp/rtp.js';
+export * from './av1.js';
+export * from './base.js';
+export * from './h264.js';
+export * from './opus.js';
+export * from './vp8.js';
+export * from './vp9.js';
+export declare function dePacketizeRtpPackets(codec: DepacketizerCodec, packets: RtpPacket[], frameFragmentBuffer?: Buffer): {
+    isKeyframe: boolean;
+    data: Buffer;
+    sequence: number;
+    timestamp: number;
+    frameFragmentBuffer?: Buffer;
+};
+export declare const depacketizerCodecs: readonly ["MPEG4/ISO/AVC", "VP8", "VP9", "OPUS", "AV1"];
+export type DepacketizerCodec = (typeof depacketizerCodecs)[number] | Lowercase<(typeof depacketizerCodecs)[number]>;

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

@@ -0,0 +1,84 @@
+"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 });
+exports.depacketizerCodecs = void 0;
+exports.dePacketizeRtpPackets = dePacketizeRtpPackets;
+const av1_js_1 = require("./av1.js");
+const h264_js_1 = require("./h264.js");
+const opus_js_1 = require("./opus.js");
+const vp8_js_1 = require("./vp8.js");
+const vp9_js_1 = require("./vp9.js");
+__exportStar(require("./av1.js"), exports);
+__exportStar(require("./base.js"), exports);
+__exportStar(require("./h264.js"), exports);
+__exportStar(require("./opus.js"), exports);
+__exportStar(require("./vp8.js"), exports);
+__exportStar(require("./vp9.js"), exports);
+function dePacketizeRtpPackets(codec, packets, frameFragmentBuffer) {
+    const basicCodecParser = (Depacketizer) => {
+        const partitions = [];
+        for (const p of packets) {
+            const codec = Depacketizer.deSerialize(p.payload, frameFragmentBuffer);
+            if (codec.fragment) {
+                frameFragmentBuffer ??= Buffer.alloc(0);
+                frameFragmentBuffer = codec.fragment;
+            }
+            else if (codec.payload) {
+                frameFragmentBuffer = undefined;
+            }
+            partitions.push(codec);
+        }
+        const isKeyframe = !!partitions.find((f) => f.isKeyframe);
+        const data = Buffer.concat(partitions.map((f) => f.payload).filter((p) => p));
+        return {
+            isKeyframe,
+            data,
+            sequence: packets.at(-1)?.header.sequenceNumber ?? 0,
+            timestamp: packets.at(-1)?.header.timestamp ?? 0,
+            frameFragmentBuffer
+        };
+    };
+    switch (codec.toUpperCase()) {
+        case 'AV1': {
+            const chunks = packets.map((p) => av1_js_1.AV1RtpPayload.deSerialize(p.payload));
+            const isKeyframe = !!chunks.find((f) => f.isKeyframe);
+            const data = av1_js_1.AV1RtpPayload.getFrame(chunks);
+            return {
+                isKeyframe,
+                data,
+                sequence: packets.at(-1)?.header.sequenceNumber ?? 0,
+                timestamp: packets.at(-1)?.header.timestamp ?? 0
+            };
+        }
+        case 'MPEG4/ISO/AVC':
+            return basicCodecParser(h264_js_1.H264RtpPayload);
+        case 'VP8':
+            return basicCodecParser(vp8_js_1.Vp8RtpPayload);
+        case 'VP9':
+            return basicCodecParser(vp9_js_1.Vp9RtpPayload);
+        case 'OPUS':
+            return basicCodecParser(opus_js_1.OpusRtpPayload);
+        default:
+            throw new Error();
+    }
+}
+exports.depacketizerCodecs = [
+    'MPEG4/ISO/AVC',
+    'VP8',
+    'VP9',
+    'OPUS',
+    'AV1'
+];

package/dist/cjs/lib/rtp/codec/leb128.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unsigned LEB128 encoder（package-private）。
+ * `codec/index.ts` の public barrel からは re-export しない。decode は `av1.ts` 側の公開 API を維持する。
+ */
+export declare function leb128encode(value: number): Buffer;

package/dist/cjs/lib/rtp/codec/leb128.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leb128encode = leb128encode;
+/**
+ * Unsigned LEB128 encoder（package-private）。
+ * `codec/index.ts` の public barrel からは re-export しない。decode は `av1.ts` 側の公開 API を維持する。
+ */
+function leb128encode(value) {
+    if (!Number.isInteger(value) || value < 0 || !Number.isSafeInteger(value)) {
+        throw new Error('LEB128 encode requires a non-negative safe integer');
+    }
+    const bytes = [];
+    let remaining = value;
+    do {
+        let byte = remaining & 0x7f;
+        remaining = Math.floor(remaining / 128);
+        if (remaining !== 0) {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    } while (remaining !== 0);
+    return Buffer.from(bytes);
+}

package/dist/cjs/lib/rtp/codec/opus.d.ts

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class OpusRtpPayload implements DePacketizerBase {
+    payload: Buffer;
+    static deSerialize(buf: Buffer): OpusRtpPayload;
+    static isDetectedFinalPacketInSequence(_header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    static createCodecPrivate(samplingFrequency?: number): Buffer<ArrayBuffer>;
+}

package/dist/cjs/lib/rtp/codec/opus.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpusRtpPayload = void 0;
+const index_js_1 = require("../../common/index.js");
+class OpusRtpPayload {
+    static deSerialize(buf) {
+        const opus = new OpusRtpPayload();
+        opus.payload = buf;
+        return opus;
+    }
+    static isDetectedFinalPacketInSequence(_header) {
+        return true;
+    }
+    get isKeyframe() {
+        return true;
+    }
+    static createCodecPrivate(samplingFrequency = 48000) {
+        return Buffer.concat([
+            Buffer.from('OpusHead'),
+            (0, index_js_1.bufferWriter)([1, 1], [1, 2]),
+            (0, index_js_1.bufferWriterLE)([2, 4, 2, 1], [312, samplingFrequency, 0, 0])
+        ]);
+    }
+}
+exports.OpusRtpPayload = OpusRtpPayload;

package/dist/cjs/lib/rtp/codec/vp8.d.ts

@@ -0,0 +1,27 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class Vp8RtpPayload implements DePacketizerBase {
+    xBit: number;
+    nBit: number;
+    sBit: number;
+    pid: number;
+    iBit?: number;
+    lBit?: number;
+    tBit?: number;
+    kBit?: number;
+    mBit?: number;
+    pictureId?: number;
+    payload: Buffer;
+    size0: number;
+    hBit?: number;
+    ver?: number;
+    pBit?: number;
+    size1: number;
+    size2: number;
+    static deSerialize(buf: Buffer): Vp8RtpPayload;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean;
+    get payloadHeaderExist(): boolean;
+    get size(): number;
+}

package/dist/cjs/lib/rtp/codec/vp8.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vp8RtpPayload = void 0;
+const index_js_1 = require("../../common/index.js");
+// RFC 7741 - RTP Payload Format for VP8 Video
+//        0 1 2 3 4 5 6 7                      0 1 2 3 4 5 6 7
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//       |X|R|N|S|R| PID | (REQUIRED)        |X|R|N|S|R| PID | (REQUIRED)
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//  X:   |I|L|T|K| RSV   | (OPTIONAL)   X:   |I|L|T|K| RSV   | (OPTIONAL)
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//  I:   |M| PictureID   | (OPTIONAL)   I:   |M| PictureID   | (OPTIONAL)
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//  L:   |   TL0PICIDX   | (OPTIONAL)        |   PictureID   |
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//  T/K: |TID|Y| KEYIDX  | (OPTIONAL)   L:   |   TL0PICIDX   | (OPTIONAL)
+//       +-+-+-+-+-+-+-+-+                   +-+-+-+-+-+-+-+-+
+//                                      T/K: |TID|Y| KEYIDX  | (OPTIONAL)
+//                                           +-+-+-+-+-+-+-+-+
+// 0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |Size0|H| VER |P|
+// +-+-+-+-+-+-+-+-+
+// |     Size1     |
+// +-+-+-+-+-+-+-+-+
+// |     Size2     |
+// +-+-+-+-+-+-+-+-+
+// | Octets 4..N of|
+// | VP8 payload   |
+// :               :
+// +-+-+-+-+-+-+-+-+
+// | OPTIONAL RTP  |
+// | padding       |
+// :               :
+// +-+-+-+-+-+-+-+-+
+class Vp8RtpPayload {
+    constructor() {
+        this.size0 = 0;
+        this.size1 = 0;
+        this.size2 = 0;
+    }
+    static deSerialize(buf) {
+        const p = new Vp8RtpPayload();
+        let offset = 0;
+        p.xBit = (0, index_js_1.getBit)(buf[offset], 0);
+        p.nBit = (0, index_js_1.getBit)(buf[offset], 2);
+        p.sBit = (0, index_js_1.getBit)(buf[offset], 3);
+        p.pid = (0, index_js_1.getBit)(buf[offset], 5, 3);
+        offset++;
+        if (p.xBit) {
+            p.iBit = (0, index_js_1.getBit)(buf[offset], 0);
+            p.lBit = (0, index_js_1.getBit)(buf[offset], 1);
+            p.tBit = (0, index_js_1.getBit)(buf[offset], 2);
+            p.kBit = (0, index_js_1.getBit)(buf[offset], 3);
+            offset++;
+        }
+        if (p.iBit) {
+            p.mBit = (0, index_js_1.getBit)(buf[offset], 0);
+            if (p.mBit) {
+                const _7 = (0, index_js_1.paddingByte)((0, index_js_1.getBit)(buf[offset], 1, 7));
+                const _8 = (0, index_js_1.paddingByte)(buf[offset + 1]);
+                p.pictureId = Number.parseInt(_7 + _8, 2);
+                offset += 2;
+            }
+            else {
+                p.pictureId = (0, index_js_1.getBit)(buf[offset], 1, 7);
+                offset++;
+            }
+        }
+        if (p.lBit) {
+            offset++;
+        }
+        if (p.lBit || p.kBit) {
+            offset++;
+        }
+        p.payload = buf.subarray(offset);
+        if (p.payloadHeaderExist) {
+            p.size0 = (0, index_js_1.getBit)(buf[offset], 0, 3);
+            p.hBit = (0, index_js_1.getBit)(buf[offset], 3);
+            p.ver = (0, index_js_1.getBit)(buf[offset], 4, 3);
+            p.pBit = (0, index_js_1.getBit)(buf[offset], 7);
+            offset++;
+            p.size1 = buf[offset];
+            offset++;
+            p.size2 = buf[offset];
+        }
+        return p;
+    }
+    static isDetectedFinalPacketInSequence(header) {
+        return header.marker;
+    }
+    get isKeyframe() {
+        return this.pBit === 0;
+    }
+    get isPartitionHead() {
+        return this.sBit === 1;
+    }
+    get payloadHeaderExist() {
+        return this.sBit === 1 && this.pid === 0;
+    }
+    get size() {
+        if (this.payloadHeaderExist) {
+            const size = this.size0 + 8 * this.size1 + 2048 * this.size2;
+            return size;
+        }
+        return 0;
+    }
+}
+exports.Vp8RtpPayload = Vp8RtpPayload;

package/dist/cjs/lib/rtp/codec/vp9.d.ts

@@ -0,0 +1,46 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class Vp9RtpPayload implements DePacketizerBase {
+    /**Picture ID (PID) present */
+    iBit: number;
+    /**Inter-picture predicted frame */
+    pBit: number;
+    /**Layer indices present */
+    lBit: number;
+    /**Flexible mode */
+    fBit: number;
+    /**Start of a frame */
+    bBit: number;
+    /**End of a frame */
+    eBit: number;
+    /**Scalability structure */
+    vBit: number;
+    zBit: number;
+    m?: number;
+    pictureId?: number;
+    tid?: number;
+    u?: number;
+    sid?: number;
+    /**inter_layer_predicted */
+    d?: number;
+    tl0PicIdx?: number;
+    pDiff: number[];
+    n_s?: number;
+    y?: number;
+    g?: number;
+    width: number[];
+    height: number[];
+    n_g: number;
+    pgT: number[];
+    pgU: number[];
+    pgP_Diff: number[][];
+    payload: Buffer;
+    static deSerialize(buf: Buffer): Vp9RtpPayload;
+    static parseRtpPayload(buf: Buffer): {
+        offset: number;
+        p: Vp9RtpPayload;
+    };
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean | 0;
+}

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

@@ -0,0 +1,161 @@
+"use strict";
+// RTP Payload Format for VP9 Video draft-ietf-payload-vp9-16 https://datatracker.ietf.org/doc/html/draft-ietf-payload-vp9
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vp9RtpPayload = void 0;
+const index_js_1 = require("../../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            |
+//         | ..            |
+//         +-+-+-+-+-+-+-+-+
+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 = (0, index_js_1.getBit)(buf[offset], 0); // PictureId present .
+        p.pBit = (0, index_js_1.getBit)(buf[offset], 1); // Inter-picture predicted.
+        p.lBit = (0, index_js_1.getBit)(buf[offset], 2); // Layer indices present.
+        p.fBit = (0, index_js_1.getBit)(buf[offset], 3); // Flexible mode.
+        p.bBit = (0, index_js_1.getBit)(buf[offset], 4); // Begins frame flag.
+        p.eBit = (0, index_js_1.getBit)(buf[offset], 5); // Ends frame flag.
+        p.vBit = (0, index_js_1.getBit)(buf[offset], 6); // Scalability structure present.
+        p.zBit = (0, index_js_1.getBit)(buf[offset], 7); // Not used for inter-layer prediction
+        offset++;
+        if (p.iBit) {
+            p.m = (0, index_js_1.getBit)(buf[offset], 0);
+            if (p.m) {
+                const _7 = (0, index_js_1.paddingByte)((0, index_js_1.getBit)(buf[offset], 1, 7));
+                const _8 = (0, index_js_1.paddingByte)(buf[offset + 1]);
+                p.pictureId = Number.parseInt(_7 + _8, 2);
+                offset += 2;
+            }
+            else {
+                p.pictureId = (0, index_js_1.getBit)(buf[offset], 1, 7);
+                offset++;
+            }
+        }
+        if (p.lBit) {
+            p.tid = (0, index_js_1.getBit)(buf[offset], 0, 3);
+            p.u = (0, index_js_1.getBit)(buf[offset], 3);
+            p.sid = (0, index_js_1.getBit)(buf[offset], 4, 3);
+            p.d = (0, index_js_1.getBit)(buf[offset], 7);
+            offset++;
+            if (p.fBit === 0) {
+                p.tl0PicIdx = buf[offset];
+                offset++;
+            }
+        }
+        if (p.fBit && p.pBit) {
+            for (;;) {
+                p.pDiff = [...p.pDiff, (0, index_js_1.getBit)(buf[offset], 0, 7)];
+                const n = (0, index_js_1.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 = (0, index_js_1.getBit)(buf[offset], 0, 3);
+            p.y = (0, index_js_1.getBit)(buf[offset], 3);
+            p.g = (0, index_js_1.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((0, index_js_1.getBit)(buf[offset], 0, 3));
+                    p.pgU.push((0, index_js_1.getBit)(buf[offset], 3));
+                    const r = (0, index_js_1.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);
+    }
+}
+exports.Vp9RtpPayload = Vp9RtpPayload;

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

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

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

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

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

@@ -0,0 +1,8 @@
+export declare function enumerate<T>(arr: T[]): [number, T][];
+export declare function growBufferSize(buf: Buffer, size: number): Buffer<ArrayBuffer>;
+export declare function Int(v: number): number;
+export declare const timer: {
+    setTimeout: (callback: (_: void) => void, delay?: number | undefined) => () => void;
+    setInterval: (callback: (_: void) => void, delay?: number | undefined) => () => void;
+};
+export declare function isMedia(buf: Buffer): boolean;