@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,203 @@
+// RTP Payload Format For AV1 https://aomediacodec.github.io/av1-rtp-spec/
+import { BitWriter2, debug, getBit } from '../imports/common.js';
+import { leb128encode } from './leb128.js';
+const log = debug('webrtc/rtp/codec/av1');
+// 4.4 AV1 Aggregation Header
+//  0 1 2 3 4 5 6 7
+// +-+-+-+-+-+-+-+-+
+// |Z|Y| W |N|-|-|-|
+// +-+-+-+-+-+-+-+-+
+// RTP payload syntax:
+// 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
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |Z|Y|0 0|N|-|-|-|  OBU element 1 size (leb128)  |               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+               |
+// :                                                               :
+// :                      OBU element 1 data                       :
+// :                                                               :
+// |                                                               |
+// |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |                               |  OBU element 2 size (leb128)  |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// :                                                               :
+// :                       OBU element 2 data                      :
+// :                                                               :
+// |                                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// :                                                               :
+// :                              ...                              :
+// :                                                               :
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// |OBU e... N size|                                               |
+// +-+-+-+-+-+-+-+-+       OBU element N data      +-+-+-+-+-+-+-+-+
+// |                                               |
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// OBU syntax:
+//     0 1 2 3 4 5 6 7
+//    +-+-+-+-+-+-+-+-+
+//    |0| type  |X|S|-| (REQUIRED)
+//    +-+-+-+-+-+-+-+-+
+// X: | TID |SID|-|-|-| (OPTIONAL)
+//    +-+-+-+-+-+-+-+-+
+//    |1|             |
+//    +-+ OBU payload |
+// S: |1|             | (OPTIONAL, variable length leb128 encoded)
+//    +-+    size     |
+//    |0|             |
+//    +-+-+-+-+-+-+-+-+
+//    |  OBU payload  |
+//    |     ...       |
+export class AV1RtpPayload {
+    constructor() {
+        this.obu_or_fragment = [];
+    }
+    static { this.deSerialize = (buf) => {
+        const p = new AV1RtpPayload();
+        let offset = 0;
+        p.zBit_RtpStartsWithFragment = getBit(buf[offset], 0);
+        p.yBit_RtpEndsWithFragment = getBit(buf[offset], 1);
+        p.w_RtpNumObus = getBit(buf[offset], 2, 2);
+        p.nBit_RtpStartsNewCodedVideoSequence = getBit(buf[offset], 4);
+        offset++;
+        if (p.nBit_RtpStartsNewCodedVideoSequence && p.zBit_RtpStartsWithFragment) {
+            throw new Error();
+        }
+        [...Array(p.w_RtpNumObus - 1).keys()].forEach((i) => {
+            const [elementSize, bytes] = leb128decode(buf.subarray(offset));
+            const start = offset + bytes;
+            const end = start + elementSize;
+            let isFragment = false;
+            if (p.zBit_RtpStartsWithFragment && i === 0) {
+                isFragment = true;
+            }
+            p.obu_or_fragment.push({ data: buf.subarray(start, end), isFragment });
+            offset += bytes + elementSize;
+        });
+        let isFragment = false;
+        if (p.yBit_RtpEndsWithFragment ||
+            (p.w_RtpNumObus === 1 && p.zBit_RtpStartsWithFragment)) {
+            isFragment = true;
+        }
+        p.obu_or_fragment.push({
+            data: buf.subarray(offset),
+            isFragment: isFragment
+        });
+        return p;
+    }; }
+    static isDetectedFinalPacketInSequence(header) {
+        return header.marker;
+    }
+    get isKeyframe() {
+        return this.nBit_RtpStartsNewCodedVideoSequence === 1;
+    }
+    static getFrame(payloads) {
+        const frames = [];
+        const objects = payloads
+            .flatMap((p) => p.obu_or_fragment)
+            .reduce((acc, cur, i) => {
+            acc[i] = cur;
+            return acc;
+        }, {});
+        const length = Object.keys(objects).length;
+        for (const i of Object.keys(objects).map(Number)) {
+            const exist = objects[i];
+            if (!exist)
+                continue;
+            const { data, isFragment } = exist;
+            if (isFragment) {
+                let fragments = [];
+                for (let head = i; head < length; head++) {
+                    const target = objects[head];
+                    if (target.isFragment) {
+                        fragments.push(target.data);
+                        delete objects[head];
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (fragments.length <= 1) {
+                    log('fragment lost, maybe packet lost');
+                    fragments = [];
+                }
+                frames.push(Buffer.concat(fragments));
+            }
+            else {
+                frames.push(data);
+            }
+        }
+        const obus = frames.map((f) => AV1Obu.deSerialize(f));
+        const lastObu = obus.pop();
+        return Buffer.concat([
+            ...obus.map((o) => {
+                o.obu_has_size_field = 1;
+                return o.serialize();
+            }),
+            lastObu.serialize()
+        ]);
+    }
+}
+export class AV1Obu {
+    static deSerialize(buf) {
+        const obu = new AV1Obu();
+        let offset = 0;
+        obu.obu_forbidden_bit = getBit(buf[offset], 0);
+        obu.obu_type =
+            OBU_TYPES[getBit(buf[offset], 1, 4)];
+        obu.obu_extension_flag = getBit(buf[offset], 5);
+        obu.obu_has_size_field = getBit(buf[offset], 6);
+        obu.obu_reserved_1bit = getBit(buf[offset], 7);
+        offset++;
+        obu.payload = buf.subarray(offset);
+        return obu;
+    }
+    serialize() {
+        const header = new BitWriter2(8)
+            .set(this.obu_forbidden_bit)
+            .set(OBU_TYPE_IDS[this.obu_type], 4)
+            .set(this.obu_extension_flag)
+            .set(this.obu_has_size_field)
+            .set(this.obu_reserved_1bit).buffer;
+        let obuSize = Buffer.alloc(0);
+        if (this.obu_has_size_field) {
+            obuSize = leb128encode(this.payload.length);
+        }
+        return Buffer.concat([header, obuSize, this.payload]);
+    }
+}
+export function leb128decode(buf) {
+    let value = 0;
+    let leb128bytes = 0;
+    for (let i = 0; i < 8; i++) {
+        if (i >= buf.length) {
+            throw new Error('LEB128 decode incomplete');
+        }
+        const leb128byte = buf.readUInt8(i);
+        value += (leb128byte & 0x7f) * 128 ** i;
+        leb128bytes++;
+        if (!(leb128byte & 0x80)) {
+            if (!Number.isSafeInteger(value)) {
+                throw new Error('LEB128 value exceeds safe integer');
+            }
+            return [value, leb128bytes];
+        }
+    }
+    throw new Error('LEB128 decode incomplete');
+}
+const OBU_TYPES = {
+    0: 'Reserved',
+    1: 'OBU_SEQUENCE_HEADER',
+    2: 'OBU_TEMPORAL_DELIMITER',
+    3: 'OBU_FRAME_HEADER',
+    4: 'OBU_TILE_GROUP',
+    5: 'OBU_METADATA',
+    6: 'OBU_FRAME',
+    7: 'OBU_REDUNDANT_FRAME_HEADER',
+    8: 'OBU_TILE_LIST',
+    15: 'OBU_PADDING'
+};
+const OBU_TYPE_IDS = Object.entries(OBU_TYPES).reduce((acc, [key, value]) => {
+    acc[value] = Number(key);
+    return acc;
+}, {});

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

@@ -0,0 +1,11 @@
+export class DePacketizerBase {
+    static deSerialize(_buf, _fragment) {
+        return {};
+    }
+    static isDetectedFinalPacketInSequence(_header) {
+        return true;
+    }
+    get isKeyframe() {
+        return true;
+    }
+}

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

@@ -0,0 +1,118 @@
+// RFC 6184 - RTP Payload Format for H.264 Video
+// pion/rtp
+import { BitStream, getBit } from '../../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
+export class H264RtpPayload {
+    static deSerialize(buf, fragment) {
+        const h264 = new H264RtpPayload();
+        let offset = 0;
+        const naluHeader = buf[offset];
+        h264.f = getBit(naluHeader, 0);
+        h264.nri = getBit(naluHeader, 1, 2);
+        h264.nalUnitType = getBit(naluHeader, 3, 5);
+        offset++;
+        h264.s = getBit(buf[offset], 0);
+        h264.e = getBit(buf[offset], 1);
+        h264.r = getBit(buf[offset], 2);
+        h264.nalUnitPayloadType = 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 < NalUnitType.stap_a) {
+            h264.payload = this.packaging(buf);
+        }
+        // Single-time aggregation packet
+        else if (h264.nalUnitType === 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 === 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 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 === NalUnitType.idrSlice ||
+            this.nalUnitPayloadType === NalUnitType.idrSlice);
+    }
+    get isPartitionHead() {
+        if (this.nalUnitType === NalUnitType.fu_a ||
+            this.nalUnitType === NalUnitType.fu_b) {
+            return this.s !== 0;
+        }
+        return true;
+    }
+}
+export const 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/esm/lib/rtp/codec/index.js

@@ -0,0 +1,66 @@
+import { AV1RtpPayload } from './av1.js';
+import { H264RtpPayload } from './h264.js';
+import { OpusRtpPayload } from './opus.js';
+import { Vp8RtpPayload } from './vp8.js';
+import { Vp9RtpPayload } from './vp9.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 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) => AV1RtpPayload.deSerialize(p.payload));
+            const isKeyframe = !!chunks.find((f) => f.isKeyframe);
+            const data = 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(H264RtpPayload);
+        case 'VP8':
+            return basicCodecParser(Vp8RtpPayload);
+        case 'VP9':
+            return basicCodecParser(Vp9RtpPayload);
+        case 'OPUS':
+            return basicCodecParser(OpusRtpPayload);
+        default:
+            throw new Error();
+    }
+}
+export const depacketizerCodecs = [
+    'MPEG4/ISO/AVC',
+    'VP8',
+    'VP9',
+    'OPUS',
+    'AV1'
+];

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

@@ -0,0 +1,20 @@
+/**
+ * Unsigned LEB128 encoder（package-private）。
+ * `codec/index.ts` の public barrel からは re-export しない。decode は `av1.ts` 側の公開 API を維持する。
+ */
+export 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/esm/lib/rtp/codec/opus.js

@@ -0,0 +1,21 @@
+import { bufferWriter, bufferWriterLE } from '../../common/index.js';
+export 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'),
+            bufferWriter([1, 1], [1, 2]),
+            bufferWriterLE([2, 4, 2, 1], [312, samplingFrequency, 0, 0])
+        ]);
+    }
+}

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

@@ -0,0 +1,105 @@
+import { getBit, paddingByte } from '../../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       |
+// :               :
+// +-+-+-+-+-+-+-+-+
+export class Vp8RtpPayload {
+    constructor() {
+        this.size0 = 0;
+        this.size1 = 0;
+        this.size2 = 0;
+    }
+    static deSerialize(buf) {
+        const p = new Vp8RtpPayload();
+        let offset = 0;
+        p.xBit = getBit(buf[offset], 0);
+        p.nBit = getBit(buf[offset], 2);
+        p.sBit = getBit(buf[offset], 3);
+        p.pid = getBit(buf[offset], 5, 3);
+        offset++;
+        if (p.xBit) {
+            p.iBit = getBit(buf[offset], 0);
+            p.lBit = getBit(buf[offset], 1);
+            p.tBit = getBit(buf[offset], 2);
+            p.kBit = getBit(buf[offset], 3);
+            offset++;
+        }
+        if (p.iBit) {
+            p.mBit = getBit(buf[offset], 0);
+            if (p.mBit) {
+                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) {
+            offset++;
+        }
+        if (p.lBit || p.kBit) {
+            offset++;
+        }
+        p.payload = buf.subarray(offset);
+        if (p.payloadHeaderExist) {
+            p.size0 = getBit(buf[offset], 0, 3);
+            p.hBit = getBit(buf[offset], 3);
+            p.ver = getBit(buf[offset], 4, 3);
+            p.pBit = 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;
+    }
+}