@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ntpTime2Sec = exports.RtcpSenderInfo = exports.RtcpSrPacket = void 0;
+const index_js_1 = require("../../common/index.js");
+const header_js_1 = require("./header.js");
+const rr_js_1 = require("./rr.js");
+// https://datatracker.ietf.org/doc/html/rfc3550#section-6.4.1
+//         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
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// header |V=2|P|    RC   |   PT=SR=200   |             length            |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         SSRC of sender                        |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// sender |              NTP timestamp, most significant word             |
+// info   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |             NTP timestamp, least significant word             |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         RTP timestamp                         |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                     sender's packet count                     |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                      sender's octet count                     |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// report |                 SSRC_1 (SSRC of first source)                 |
+// block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   1    | fraction lost |       cumulative number of packets lost       |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |           extended highest sequence number received           |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                      interarrival jitter                      |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                         last SR (LSR)                         |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//        |                   delay since last SR (DLSR)                  |
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+// report |                 SSRC_2 (SSRC of second source)                |
+// block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   2    :                               ...                             :
+//        +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//        |                  profile-specific extensions                  |
+//        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+class RtcpSrPacket {
+    static { this.type = 200; }
+    constructor(props) {
+        this.ssrc = 0;
+        this.reports = [];
+        this.type = RtcpSrPacket.type;
+        Object.assign(this, props);
+    }
+    toJSON() {
+        return {
+            ssrc: this.ssrc,
+            senderInfo: this.senderInfo.toJSON(),
+            reports: this.reports.map((r) => r.toJSON())
+        };
+    }
+    serialize() {
+        let payload = Buffer.alloc(4);
+        payload.writeUInt32BE(this.ssrc);
+        payload = Buffer.concat([payload, this.senderInfo.serialize()]);
+        payload = Buffer.concat([
+            payload,
+            ...this.reports.map((report) => report.serialize())
+        ]);
+        return header_js_1.RtcpHeader.serialize(RtcpSrPacket.type, this.reports.length, payload, Math.floor(payload.length / 4));
+    }
+    static deSerialize(payload, count) {
+        const ssrc = payload.readUInt32BE();
+        const senderInfo = RtcpSenderInfo.deSerialize(payload.subarray(4, 24));
+        let pos = 24;
+        const reports = [];
+        for (let _ = 0; _ < count; _++) {
+            reports.push(rr_js_1.RtcpReceiverInfo.deSerialize(payload.subarray(pos, pos + 24)));
+            pos += 24;
+        }
+        const packet = new RtcpSrPacket({ ssrc, senderInfo, reports });
+        return packet;
+    }
+}
+exports.RtcpSrPacket = RtcpSrPacket;
+class RtcpSenderInfo {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+    toJSON() {
+        return {
+            ntpTimestamp: (0, exports.ntpTime2Sec)(this.ntpTimestamp),
+            rtpTimestamp: this.rtpTimestamp
+        };
+    }
+    serialize() {
+        return (0, index_js_1.bufferWriter)([8, 4, 4, 4], [this.ntpTimestamp, this.rtpTimestamp, this.packetCount, this.octetCount]);
+    }
+    static deSerialize(data) {
+        const [ntpTimestamp, rtpTimestamp, packetCount, octetCount] = (0, index_js_1.bufferReader)(data, [8, 4, 4, 4]);
+        return new RtcpSenderInfo({
+            ntpTimestamp,
+            rtpTimestamp,
+            packetCount,
+            octetCount
+        });
+    }
+}
+exports.RtcpSenderInfo = RtcpSenderInfo;
+const ntpTime2Sec = (ntp) => {
+    const [ntpSec, ntpMsec] = (0, index_js_1.bufferReader)((0, index_js_1.bufferWriter)([8], [ntp]), [4, 4]);
+    return Number(`${ntpSec}.${ntpMsec}`);
+};
+exports.ntpTime2Sec = ntpTime2Sec;

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

@@ -0,0 +1,72 @@
+import type { Extension } from './rtp.js';
+export declare const RTP_EXTENSION_URI: {
+    readonly sdesMid: "urn:ietf:params:rtp-hdrext:sdes:mid";
+    readonly sdesRTPStreamID: "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id";
+    readonly repairedRtpStreamId: "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id";
+    readonly transportWideCC: "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01";
+    readonly absSendTime: "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time";
+    readonly dependencyDescriptor: "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension";
+    readonly audioLevelIndication: "urn:ietf:params:rtp-hdrext:ssrc-audio-level";
+    readonly videoOrientation: "urn:3gpp:video-orientation";
+};
+export type TransportWideCCPayload = number;
+export type AudioLevelIndicationPayload = {
+    v: boolean;
+    level: number;
+};
+export interface videoOrientationPayload {
+    /**
+   Camera: indicates the direction of the camera used for this video stream. It can be used by the MTSI client in
+  receiver to e.g. display the received video differently depending on the source camera.
+  0: Front-facing camera, facing the user. If camera direction is unknown by the sending MTSI client in the terminal
+  then this is the default value used.
+  1: Back-facing camera, facing away from the user.
+ */
+    c: number;
+    /**
+   F = Flip: indicates a horizontal (left-right flip) mirror operation on the video as sent on the link.
+  0: No flip operation. If the sending MTSI client in terminal does not know if a horizontal mirror operation is
+  necessary, then this is the default value used.
+  1: Horizontal flip operation
+   */
+    f: number;
+    /**
+   R1, R0 = Rotation: indicates the rotation of the video as transmitted on the link. The receiver should rotate the video to
+  compensate that rotation. E.g. a 90° Counter Clockwise rotation should be compensated by the receiver with a 90°
+  Clockwise rotation prior to displaying.
+
+    +----+----+-----------------------------------------------+------------------------------+
+  | R1 | R0 | Rotation of the video as sent on the link     | Rotation on the receiver      |
+  |    |    |                                               | before display                |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  0 |  0 | 0° rotation                                   | None                         |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  0 |  1 | 90° Counter Clockwise (CCW) rotation or 270°  | 90° Clockwise (CW) rotation  |
+  |    |    | Clockwise (CW) rotation                       |                              |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  1 |  0 | 180° CCW rotation or 180° CW rotation         | 180° CW rotation             |
+  +----+----+-----------------------------------------------+------------------------------+
+  |  1 |  1 | 270° CCW rotation or 90° CW rotation          | 90° CCW rotation             |
+  +----+----+-----------------------------------------------+------------------------------+
+
+   */
+    r1: number;
+    r0: number;
+}
+export interface Extensions {
+    [uri: string]: any;
+}
+export declare function rtpHeaderExtensionsParser(extensions: Extension[], extIdUriMap: {
+    [id: number]: string;
+}): Extensions;
+export declare function serializeSdesMid(id: string): Buffer<ArrayBuffer>;
+export declare function serializeSdesRTPStreamID(id: string): Buffer<ArrayBuffer>;
+export declare function serializeRepairedRtpStreamId(id: string): Buffer<ArrayBuffer>;
+export declare function serializeTransportWideCC(transportSequenceNumber: number): Buffer<ArrayBuffer>;
+export declare function serializeAbsSendTime(ntpTime: bigint): Buffer<ArrayBuffer>;
+export declare function serializeAudioLevelIndication(level: number): Buffer<ArrayBufferLike>;
+export declare function deserializeString(buf: Buffer): string;
+export declare function deserializeUint16BE(buf: Buffer): number;
+export declare function deserializeAbsSendTime(buf: Buffer): any;
+export declare function deserializeAudioLevelIndication(buf: Buffer): AudioLevelIndicationPayload;
+export declare function deserializeVideoOrientation(payload: Buffer): videoOrientationPayload;

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTP_EXTENSION_URI = void 0;
+exports.rtpHeaderExtensionsParser = rtpHeaderExtensionsParser;
+exports.serializeSdesMid = serializeSdesMid;
+exports.serializeSdesRTPStreamID = serializeSdesRTPStreamID;
+exports.serializeRepairedRtpStreamId = serializeRepairedRtpStreamId;
+exports.serializeTransportWideCC = serializeTransportWideCC;
+exports.serializeAbsSendTime = serializeAbsSendTime;
+exports.serializeAudioLevelIndication = serializeAudioLevelIndication;
+exports.deserializeString = deserializeString;
+exports.deserializeUint16BE = deserializeUint16BE;
+exports.deserializeAbsSendTime = deserializeAbsSendTime;
+exports.deserializeAudioLevelIndication = deserializeAudioLevelIndication;
+exports.deserializeVideoOrientation = deserializeVideoOrientation;
+const index_js_1 = require("../../common/index.js");
+exports.RTP_EXTENSION_URI = {
+    sdesMid: 'urn:ietf:params:rtp-hdrext:sdes:mid',
+    sdesRTPStreamID: 'urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id',
+    repairedRtpStreamId: 'urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id',
+    transportWideCC: 'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
+    absSendTime: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
+    dependencyDescriptor: 'https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension',
+    audioLevelIndication: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level',
+    videoOrientation: 'urn:3gpp:video-orientation'
+};
+function rtpHeaderExtensionsParser(extensions, extIdUriMap) {
+    return extensions
+        .map((extension) => {
+        const uri = extIdUriMap[extension.id];
+        if (!uri) {
+            return { uri: 'unknown', value: extension.payload };
+        }
+        switch (uri) {
+            case exports.RTP_EXTENSION_URI.sdesMid:
+            case exports.RTP_EXTENSION_URI.sdesRTPStreamID:
+            case exports.RTP_EXTENSION_URI.repairedRtpStreamId:
+                return { uri, value: deserializeString(extension.payload) };
+            case exports.RTP_EXTENSION_URI.transportWideCC:
+                return { uri, value: deserializeUint16BE(extension.payload) };
+            case exports.RTP_EXTENSION_URI.absSendTime:
+                return {
+                    uri,
+                    value: deserializeAbsSendTime(extension.payload)
+                };
+            case exports.RTP_EXTENSION_URI.audioLevelIndication: {
+                return {
+                    uri,
+                    value: deserializeAudioLevelIndication(extension.payload)
+                };
+            }
+            case exports.RTP_EXTENSION_URI.videoOrientation:
+                return { uri, value: deserializeVideoOrientation(extension.payload) };
+            default:
+                return { uri, value: extension.payload };
+        }
+    })
+        .reduce((acc, cur) => {
+        if (cur)
+            acc[cur.uri] = cur.value;
+        return acc;
+    }, {});
+}
+function serializeSdesMid(id) {
+    return Buffer.from(id);
+}
+function serializeSdesRTPStreamID(id) {
+    return Buffer.from(id);
+}
+function serializeRepairedRtpStreamId(id) {
+    return Buffer.from(id);
+}
+function serializeTransportWideCC(transportSequenceNumber) {
+    const buf = Buffer.allocUnsafe(2);
+    buf.writeUInt16BE(transportSequenceNumber);
+    return buf;
+}
+function serializeAbsSendTime(ntpTime) {
+    const buf = Buffer.alloc(3);
+    const time = (ntpTime >> 14n) & 0x00ffffffn;
+    buf.writeUIntBE(Number(time), 0, 3);
+    return buf;
+}
+function serializeAudioLevelIndication(level) {
+    const stream = new index_js_1.BitStream(Buffer.alloc(1));
+    stream.writeBits(1, 1);
+    stream.writeBits(7, level);
+    return stream.uint8Array;
+}
+function deserializeString(buf) {
+    return buf.toString();
+}
+function deserializeUint16BE(buf) {
+    return buf.readUInt16BE();
+}
+function deserializeAbsSendTime(buf) {
+    return (0, index_js_1.bufferReader)(buf, [3])[0];
+}
+function deserializeAudioLevelIndication(buf) {
+    const stream = new index_js_1.BitStream(buf);
+    const value = {
+        v: stream.readBits(1) === 1,
+        level: stream.readBits(7)
+    };
+    return value;
+}
+function deserializeVideoOrientation(payload) {
+    const stream = new index_js_1.BitStream(payload);
+    stream.readBits(4);
+    const value = {
+        c: stream.readBits(1),
+        f: stream.readBits(1),
+        r1: stream.readBits(1),
+        r0: stream.readBits(1)
+    };
+    return value;
+}

package/dist/cjs/lib/rtp/rtp/red/encoder.d.ts

@@ -0,0 +1,13 @@
+import { Red } from './packet.js';
+export declare class RedEncoder {
+    distance: number;
+    private cache;
+    cacheSize: number;
+    constructor(distance?: number);
+    push(payload: {
+        block: Buffer;
+        timestamp: number;
+        blockPT: number;
+    }): void;
+    build(): Red;
+}

package/dist/cjs/lib/rtp/rtp/red/encoder.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedEncoder = void 0;
+const index_js_1 = require("../../../common/index.js");
+const packet_js_1 = require("./packet.js");
+class RedEncoder {
+    constructor(distance = 1) {
+        this.distance = distance;
+        this.cache = [];
+        this.cacheSize = 10;
+    }
+    push(payload) {
+        this.cache.push(payload);
+        if (this.cache.length > this.cacheSize) {
+            this.cache.shift();
+        }
+    }
+    build() {
+        const red = new packet_js_1.Red();
+        const redundantPayloads = this.cache.slice(-(this.distance + 1));
+        const presentPayload = redundantPayloads.pop();
+        if (!presentPayload) {
+            return red;
+        }
+        redundantPayloads.forEach((redundant) => {
+            const timestampOffset = (0, index_js_1.uint32Add)(presentPayload.timestamp, -redundant.timestamp);
+            if (timestampOffset > Max14Uint) {
+                return;
+            }
+            red.blocks.push({
+                block: redundant.block,
+                blockPT: redundant.blockPT,
+                timestampOffset
+            });
+        });
+        red.blocks.push({
+            block: presentPayload.block,
+            blockPT: presentPayload.blockPT
+        });
+        return red;
+    }
+}
+exports.RedEncoder = RedEncoder;
+const Max14Uint = (0x01 << 14) - 1;

package/dist/cjs/lib/rtp/rtp/red/handler.d.ts

@@ -0,0 +1,6 @@
+import { type Red, RtpPacket } from '../../index.js';
+export declare class RedHandler {
+    private readonly size;
+    private sequenceNumbers;
+    push(red: Red, base: RtpPacket): RtpPacket[];
+}

package/dist/cjs/lib/rtp/rtp/red/handler.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedHandler = void 0;
+const index_js_1 = require("../../index.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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |F|   block PT  |  timestamp offset         |   block length    |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// 0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |0|   Block PT  |
+// +-+-+-+-+-+-+-+-+
+class RedHandler {
+    constructor() {
+        this.size = 150;
+        this.sequenceNumbers = [];
+    }
+    push(red, base) {
+        const packets = [];
+        red.blocks.forEach(({ blockPT, timestampOffset, block }, i) => {
+            const sequenceNumber = (0, index_js_1.uint16Add)(base.header.sequenceNumber, -(red.blocks.length - (i + 1)));
+            if (timestampOffset) {
+                packets.push(new index_js_1.RtpPacket(new index_js_1.RtpHeader({
+                    timestamp: (0, index_js_1.uint32Add)(base.header.timestamp, -timestampOffset),
+                    payloadType: blockPT,
+                    ssrc: base.header.ssrc,
+                    sequenceNumber,
+                    marker: true
+                }), block));
+            }
+            else {
+                packets.push(new index_js_1.RtpPacket(new index_js_1.RtpHeader({
+                    timestamp: base.header.timestamp,
+                    payloadType: blockPT,
+                    ssrc: base.header.ssrc,
+                    sequenceNumber,
+                    marker: true
+                }), block));
+            }
+        });
+        const filtered = packets.filter((p) => {
+            // duplicate
+            if (this.sequenceNumbers.includes(p.header.sequenceNumber)) {
+                return false;
+            }
+            else {
+                // buffer overflow
+                if (this.sequenceNumbers.length > this.size) {
+                    this.sequenceNumbers.shift();
+                }
+                this.sequenceNumbers.push(p.header.sequenceNumber);
+                return true;
+            }
+        });
+        return filtered;
+    }
+}
+exports.RedHandler = RedHandler;

package/dist/cjs/lib/rtp/rtp/red/packet.d.ts

@@ -0,0 +1,26 @@
+export declare class Red {
+    header: RedHeader;
+    blocks: {
+        block: Buffer;
+        blockPT: number;
+        /**14bit */
+        timestampOffset?: number;
+    }[];
+    static deSerialize(bufferOrArrayBuffer: Buffer | ArrayBuffer): Red;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare class RedHeader {
+    fields: RedHeaderField[];
+    static deSerialize(buf: Buffer): readonly [RedHeader, number];
+    serialize(): Buffer<ArrayBuffer>;
+}
+interface RedHeaderField {
+    /**ヘッダーの最初のビットは、別のヘッダーブロックが続くかどうかを示す。 1の場合は、さらにヘッダーブロックが続き、0の場合は、これが最後のヘッダーブロックとなります。 */
+    fBit: number;
+    blockPT: number;
+    /**14bit */
+    timestampOffset?: number;
+    /**10bit */
+    blockLength?: number;
+}
+export {};

package/dist/cjs/lib/rtp/rtp/red/packet.js

@@ -0,0 +1,112 @@
+"use strict";
+// rfc2198
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedHeader = exports.Red = void 0;
+const common_js_1 = require("../../imports/common.js");
+const log = (0, common_js_1.debug)('packages/rtp/src/rtp/red/packet.ts');
+// 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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |F|   block PT  |  timestamp offset         |   block length    |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// 0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |0|   Block PT  |
+// +-+-+-+-+-+-+-+-+
+class Red {
+    constructor() {
+        this.blocks = [];
+    }
+    static deSerialize(bufferOrArrayBuffer) {
+        const buf = bufferOrArrayBuffer instanceof ArrayBuffer
+            ? Buffer.from(bufferOrArrayBuffer)
+            : bufferOrArrayBuffer;
+        const red = new Red();
+        let offset = 0;
+        [red.header, offset] = RedHeader.deSerialize(buf);
+        red.header.fields.forEach(({ blockLength, timestampOffset, blockPT }) => {
+            if (blockLength && timestampOffset) {
+                const block = buf.subarray(offset, offset + blockLength);
+                red.blocks.push({ block, blockPT, timestampOffset });
+                offset += blockLength;
+            }
+            else {
+                const block = buf.subarray(offset);
+                red.blocks.push({ block, blockPT });
+            }
+        });
+        return red;
+    }
+    serialize() {
+        this.header = new RedHeader();
+        for (const { timestampOffset, blockPT, block } of this.blocks) {
+            if (timestampOffset) {
+                this.header.fields.push({
+                    fBit: 1,
+                    blockPT,
+                    blockLength: block.length,
+                    timestampOffset
+                });
+            }
+            else {
+                this.header.fields.push({ fBit: 0, blockPT });
+            }
+        }
+        let buf = this.header.serialize();
+        for (const { block } of this.blocks) {
+            buf = Buffer.concat([buf, block]);
+        }
+        return buf;
+    }
+}
+exports.Red = Red;
+class RedHeader {
+    constructor() {
+        this.fields = [];
+    }
+    static deSerialize(buf) {
+        let offset = 0;
+        const header = new RedHeader();
+        for (;;) {
+            const field = {};
+            header.fields.push(field);
+            const bitStream = new common_js_1.BitStream(buf.subarray(offset));
+            field.fBit = bitStream.readBits(1);
+            field.blockPT = bitStream.readBits(7);
+            offset++;
+            if (field.fBit === 0) {
+                break;
+            }
+            field.timestampOffset = bitStream.readBits(14);
+            field.blockLength = bitStream.readBits(10);
+            offset += 3;
+        }
+        return [header, offset];
+    }
+    serialize() {
+        let buf = Buffer.alloc(0);
+        for (const field of this.fields) {
+            try {
+                if (field.timestampOffset && field.blockLength) {
+                    const bitStream = new common_js_1.BitStream(Buffer.alloc(4))
+                        .writeBits(1, field.fBit)
+                        .writeBits(7, field.blockPT)
+                        .writeBits(14, field.timestampOffset)
+                        .writeBits(10, field.blockLength);
+                    buf = Buffer.concat([buf, bitStream.uint8Array]);
+                }
+                else {
+                    const bitStream = new common_js_1.BitStream(Buffer.alloc(1))
+                        .writeBits(1, 0)
+                        .writeBits(7, field.blockPT);
+                    buf = Buffer.concat([buf, bitStream.uint8Array]);
+                }
+            }
+            catch (error) {
+                log(error?.message);
+            }
+        }
+        return buf;
+    }
+}
+exports.RedHeader = RedHeader;

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

@@ -0,0 +1,44 @@
+export type Extension = {
+    id: number;
+    payload: Buffer;
+};
+export declare const ExtensionProfiles: {
+    readonly OneByte: 48862;
+    readonly TwoByte: 4096;
+};
+type ExtensionProfile = (typeof ExtensionProfiles)[keyof typeof ExtensionProfiles];
+export declare class RtpHeader {
+    version: number;
+    padding: boolean;
+    paddingSize: number;
+    extension: boolean;
+    marker: boolean;
+    payloadOffset: number;
+    payloadType: number;
+    /**16bit, 初期値はランダムである必要があります*/
+    sequenceNumber: number;
+    /**32bit microsec (milli/1000), 初期値はランダムである必要があります*/
+    timestamp: number;
+    ssrc: number;
+    csrcLength: number;
+    csrc: number[];
+    extensionProfile: ExtensionProfile;
+    /**deserialize only */
+    extensionLength?: number;
+    extensions: Extension[];
+    constructor(props?: Partial<RtpHeader>);
+    static deSerialize(rawPacket: Buffer): RtpHeader;
+    get serializeSize(): number;
+    serialize(size: number): Buffer<ArrayBuffer>;
+}
+export declare class RtpPacket {
+    header: RtpHeader;
+    payload: Buffer;
+    constructor(header: RtpHeader, payload: Buffer);
+    get serializeSize(): number;
+    clone(): RtpPacket;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(buf: Buffer): RtpPacket;
+    clear(): void;
+}
+export {};