@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/lib/peer/utils.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = exports.MediaStreamTrackFactory = exports.createSelfSignedCertificate = exports.compactNtp = exports.ntpTimeToEpochMs = exports.absSendTimeOf = exports.ntpTime = exports.timestampSeconds = exports.microTime = exports.milliTime = exports.andDirection = void 0;
+exports.fingerprint = fingerprint;
+exports.normalizeFingerprintAlgorithm = normalizeFingerprintAlgorithm;
+exports.normalizeFingerprintValue = normalizeFingerprintValue;
+exports.isDtls = isDtls;
+exports.reverseSimulcastDirection = reverseSimulcastDirection;
+exports.reverseDirection = reverseDirection;
+exports.parseIceServers = parseIceServers;
+exports.resolveTurnTransport = resolveTurnTransport;
+const node_crypto_1 = require("node:crypto");
+const node_dgram_1 = require("node:dgram");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const common_js_1 = require("./imports/common.js");
+const dtls_js_1 = require("./imports/dtls.js");
+const rtpTransceiver_js_1 = require("./media/rtpTransceiver.js");
+const track_js_1 = require("./media/track.js");
+const log = (0, common_js_1.debug)('webrtc/peer/utils');
+function fingerprint(file, hashName) {
+    const upper = (s) => s.toUpperCase();
+    const colon = (s) => s.match(/(.{2})/g).join(':');
+    const hash = (0, node_crypto_1.createHash)(hashName).update(file).digest('hex');
+    return colon(upper(hash));
+}
+const fingerprintHashAlgorithms = {
+    sha1: 'sha1',
+    'sha-1': 'sha1',
+    sha224: 'sha224',
+    'sha-224': 'sha224',
+    sha256: 'sha256',
+    'sha-256': 'sha256',
+    sha384: 'sha384',
+    'sha-384': 'sha384',
+    sha512: 'sha512',
+    'sha-512': 'sha512'
+};
+function normalizeFingerprintAlgorithm(algorithm) {
+    return fingerprintHashAlgorithms[algorithm.trim().toLowerCase()];
+}
+function normalizeFingerprintValue(value) {
+    return value.replace(/[^0-9a-f]/gi, '').toLowerCase();
+}
+function isDtls(buf) {
+    const firstByte = buf[0];
+    return firstByte > 19 && firstByte < 64;
+}
+function reverseSimulcastDirection(dir) {
+    if (dir === 'recv')
+        return 'send';
+    return 'recv';
+}
+const andDirection = (a, b) => rtpTransceiver_js_1.Directions[rtpTransceiver_js_1.Directions.indexOf(a) & rtpTransceiver_js_1.Directions.indexOf(b)];
+exports.andDirection = andDirection;
+function reverseDirection(dir) {
+    if (dir === 'sendonly')
+        return 'recvonly';
+    if (dir === 'recvonly')
+        return 'sendonly';
+    return dir;
+}
+exports.milliTime = Date.now;
+const startupTimestampInMicroseconds = BigInt(Date.now()) * 1000n - process.hrtime.bigint() / 1000n;
+const microTime = () => {
+    return startupTimestampInMicroseconds + process.hrtime.bigint() / 1000n;
+};
+exports.microTime = microTime;
+const timestampSeconds = () => Date.now() / 1000;
+exports.timestampSeconds = timestampSeconds;
+/**https://datatracker.ietf.org/doc/html/rfc3550#section-4 */
+//The NTP epoch (1900) from the Unix epoch, in milliseconds
+const NTP_EPOCH_MS = Date.UTC(1900, 0, 1);
+/**
+ * The time now as an NTP timestamp (RFC 5905): 32 bits of seconds since 1900, then 32 bits of fraction of a second
+ */
+const ntpTime = (epochMs = node_perf_hooks_1.performance.timeOrigin + node_perf_hooks_1.performance.now()) => {
+    const ms = epochMs - NTP_EPOCH_MS;
+    const seconds = Math.floor(ms / 1000);
+    const fraction = Math.floor(((ms - seconds * 1000) / 1000) * 2 ** 32);
+    return (BigInt(seconds) << 32n) | BigInt(fraction);
+};
+exports.ntpTime = ntpTime;
+/**
+ * The abs-send-time header extension of a time: the 6 low bits of the seconds and the 18 high bits of the fraction of
+ * its NTP timestamp, without the bigints of ntpTime() (it is computed for each packet)
+ * @param epochMs The time, in milliseconds since the Unix epoch.
+ */
+const absSendTimeOf = (epochMs) => {
+    const ms = epochMs - NTP_EPOCH_MS;
+    const seconds = Math.floor(ms / 1000);
+    const fraction = Math.floor(((ms - seconds * 1000) / 1000) * 2 ** 32);
+    const buf = Buffer.allocUnsafe(3);
+    buf.writeUIntBE(((seconds & 0x3f) << 18) | (fraction >>> 14), 0, 3);
+    return buf;
+};
+exports.absSendTimeOf = absSendTimeOf;
+/**
+ * The time of an NTP timestamp, in milliseconds since the Unix epoch
+ * @param ntp
+ */
+const ntpTimeToEpochMs = (ntp) => {
+    const seconds = Number(ntp >> 32n);
+    const fraction = Number(ntp & 0xffffffffn);
+    return seconds * 1000 + (fraction / 2 ** 32) * 1000 + NTP_EPOCH_MS;
+};
+exports.ntpTimeToEpochMs = ntpTimeToEpochMs;
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3550#section-4
+ * @param ntp
+ * @returns 32bit
+ */
+const compactNtp = (ntp) => {
+    //The middle 32 bits: the low 16 bits of the seconds, the high 16 bits of the fraction
+    return Number((ntp >> 16n) & 0xffffffffn);
+};
+exports.compactNtp = compactNtp;
+function parseIceServers(iceServers) {
+    //The first STUN and TURN URLs, and all of them in stunServers and turnServers
+    const options = { stunServers: [], turnServers: [] };
+    for (const iceServer of iceServers) {
+        const urls = Array.isArray(iceServer.urls)
+            ? iceServer.urls
+            : [iceServer.urls];
+        for (const url of urls) {
+            const parsed = parseIceServerUrl(url);
+            if (!parsed) {
+                continue;
+            }
+            if (parsed.kind === 'stun') {
+                options.stunServer ??= parsed.address;
+                options.stunServers.push(parsed.address);
+            }
+            if (parsed.kind === 'turn') {
+                if (!options.turnServer) {
+                    options.turnServer = parsed.address;
+                    options.turnTransport = parsed.transport;
+                    options.turnUsername = iceServer.username;
+                    options.turnPassword = iceServer.credential;
+                }
+                if (iceServer.username && iceServer.credential) {
+                    options.turnServers.push({
+                        address: parsed.address,
+                        username: iceServer.username,
+                        password: iceServer.credential,
+                        transport: parsed.transport
+                    });
+                }
+            }
+        }
+    }
+    log('iceOptions', options);
+    return options;
+}
+function resolveTurnTransport({ configuredTurnTransport, forceTurnTCP, parsedTurnTransport }) {
+    if (parsedTurnTransport) {
+        return parsedTurnTransport;
+    }
+    if (configuredTurnTransport) {
+        return configuredTurnTransport;
+    }
+    if (forceTurnTCP) {
+        return 'tcp';
+    }
+    return undefined;
+}
+function parseIceServerUrl(url) {
+    const matched = /^(stun|stuns|turn|turns):(.+)$/i.exec(url.trim());
+    if (!matched) {
+        return;
+    }
+    const [, rawScheme, rawRest] = matched;
+    const scheme = rawScheme.toLowerCase();
+    const [authority] = rawRest.split('?', 1);
+    const [, query = ''] = rawRest.split('?');
+    const address = parseAddress(authority, defaultPort(scheme));
+    if (!address) {
+        return;
+    }
+    if (scheme === 'stun' || scheme === 'stuns') {
+        return { kind: 'stun', address };
+    }
+    const queryParams = new URLSearchParams(query);
+    const transportParam = queryParams.get('transport');
+    const transport = resolveParsedTurnTransport({
+        scheme,
+        transportParam
+    });
+    if (transport === 'invalid') {
+        return;
+    }
+    return {
+        kind: 'turn',
+        address,
+        transport
+    };
+}
+function resolveParsedTurnTransport({ scheme, transportParam }) {
+    if (transportParam == null) {
+        return scheme === 'turns' ? 'tls' : undefined;
+    }
+    if (transportParam === 'udp') {
+        return scheme === 'turns' ? 'invalid' : 'udp';
+    }
+    if (transportParam === 'tcp') {
+        return scheme === 'turns' ? 'tls' : 'tcp';
+    }
+    return 'invalid';
+}
+function defaultPort(scheme) {
+    if (scheme === 'stuns' || scheme === 'turns') {
+        return 5349;
+    }
+    return 3478;
+}
+function parseAddress(value, fallbackPort) {
+    const authority = value.startsWith('//') ? value.slice(2) : value;
+    if (!authority) {
+        return;
+    }
+    if (authority.startsWith('[')) {
+        const closingBracket = authority.indexOf(']');
+        if (closingBracket === -1) {
+            return;
+        }
+        const host = authority.slice(1, closingBracket);
+        const port = parsePort(authority.slice(closingBracket + 1), fallbackPort);
+        return [host, port];
+    }
+    const firstColon = authority.indexOf(':');
+    const lastColon = authority.lastIndexOf(':');
+    if (firstColon !== -1 && firstColon === lastColon) {
+        return [
+            authority.slice(0, firstColon),
+            parsePort(authority.slice(firstColon + 1), fallbackPort)
+        ];
+    }
+    return [authority, fallbackPort];
+}
+function parsePort(value, fallbackPort) {
+    const portString = value.startsWith(':') ? value.slice(1) : value;
+    const port = Number.parseInt(portString, 10);
+    return Number.isFinite(port) ? port : fallbackPort;
+}
+/**
+ *
+ * @param signatureHash
+ * @param namedCurveAlgorithm necessary when use ecdsa
+ */
+exports.createSelfSignedCertificate = dtls_js_1.CipherContext.createSelfSignedCertificateWithKey;
+class MediaStreamTrackFactory {
+    static async rtpSource({ port, kind, cb }) {
+        port ??= await (0, common_js_1.randomPort)();
+        const track = new track_js_1.MediaStreamTrack({ kind });
+        const udp = (0, node_dgram_1.createSocket)('udp4');
+        udp.bind(port);
+        const onMessage = (msg) => {
+            if (cb) {
+                msg = cb(msg);
+            }
+            track.writeRtp(msg);
+        };
+        udp.addListener('message', onMessage);
+        const dispose = () => {
+            udp.removeListener('message', onMessage);
+            try {
+                udp.close();
+            }
+            catch {
+                //Already closed
+            }
+        };
+        return [track, port, dispose];
+    }
+}
+exports.MediaStreamTrackFactory = MediaStreamTrackFactory;
+/**
+ * Merge two objects. If a property value in the source object is undefined or
+ * when casted is equal to undefined (== undefined), then it will not overwrite
+ * the value of the property in the destination object.
+ */
+const deepMerge = (dst, src) => {
+    if (!dst || typeof dst !== 'object') {
+        if (src !== null && typeof src === 'object') {
+            return src;
+        }
+        else {
+            return dst;
+        }
+    }
+    if (!src || typeof src !== 'object') {
+        if (src == undefined) {
+            return dst;
+        }
+        return src;
+    }
+    for (const key in src) {
+        if (Object.prototype.hasOwnProperty.call(src, key)) {
+            const sourceValue = src[key];
+            if (sourceValue != undefined) {
+                dst[key] = sourceValue;
+            }
+        }
+    }
+    return dst;
+};
+exports.deepMerge = deepMerge;

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

@@ -0,0 +1,56 @@
+import type { RtpHeader } from '../index.js';
+export declare class AV1RtpPayload {
+    /**
+   * RtpStartsWithFragment
+   * MUST be set to 1 if the first OBU element is an OBU fragment that is a continuation of an OBU fragment from the previous packet, and MUST be set to 0 otherwise.
+   */
+    zBit_RtpStartsWithFragment: number;
+    /**
+   * RtpEndsWithFragment
+   * MUST be set to 1 if the last OBU element is an OBU fragment that will continue in the next packet, and MUST be set to 0 otherwise.
+   */
+    yBit_RtpEndsWithFragment: number;
+    /**
+   * RtpNumObus
+   * two bit field that describes the number of OBU elements in the packet. This field MUST be set equal to 0 or equal to the number of OBU elements contained in the packet. If set to 0, each OBU element MUST be preceded by a length field.
+   */
+    w_RtpNumObus: number;
+    /**
+   * RtpStartsNewCodedVideoSequence
+   * MUST be set to 1 if the packet is the first packet of a coded video sequence, and MUST be set to 0 otherwise.
+   */
+    nBit_RtpStartsNewCodedVideoSequence: number;
+    obu_or_fragment: {
+        data: Buffer;
+        isFragment: boolean;
+    }[];
+    static deSerialize: (buf: Buffer) => AV1RtpPayload;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    static getFrame(payloads: AV1RtpPayload[]): Buffer<ArrayBuffer>;
+}
+export declare class AV1Obu {
+    obu_forbidden_bit: number;
+    obu_type: OBU_TYPE;
+    obu_extension_flag: number;
+    obu_has_size_field: number;
+    obu_reserved_1bit: number;
+    payload: Buffer;
+    static deSerialize(buf: Buffer): AV1Obu;
+    serialize(): Buffer<ArrayBuffer>;
+}
+export declare function leb128decode(buf: Buffer): number[];
+declare const OBU_TYPES: {
+    readonly 0: "Reserved";
+    readonly 1: "OBU_SEQUENCE_HEADER";
+    readonly 2: "OBU_TEMPORAL_DELIMITER";
+    readonly 3: "OBU_FRAME_HEADER";
+    readonly 4: "OBU_TILE_GROUP";
+    readonly 5: "OBU_METADATA";
+    readonly 6: "OBU_FRAME";
+    readonly 7: "OBU_REDUNDANT_FRAME_HEADER";
+    readonly 8: "OBU_TILE_LIST";
+    readonly 15: "OBU_PADDING";
+};
+type OBU_TYPE = (typeof OBU_TYPES)[keyof typeof OBU_TYPES];
+export {};

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

@@ -0,0 +1,209 @@
+"use strict";
+// RTP Payload Format For AV1 https://aomediacodec.github.io/av1-rtp-spec/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AV1Obu = exports.AV1RtpPayload = void 0;
+exports.leb128decode = leb128decode;
+const common_js_1 = require("../imports/common.js");
+const leb128_js_1 = require("./leb128.js");
+const log = (0, common_js_1.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  |
+//    |     ...       |
+class AV1RtpPayload {
+    constructor() {
+        this.obu_or_fragment = [];
+    }
+    static { this.deSerialize = (buf) => {
+        const p = new AV1RtpPayload();
+        let offset = 0;
+        p.zBit_RtpStartsWithFragment = (0, common_js_1.getBit)(buf[offset], 0);
+        p.yBit_RtpEndsWithFragment = (0, common_js_1.getBit)(buf[offset], 1);
+        p.w_RtpNumObus = (0, common_js_1.getBit)(buf[offset], 2, 2);
+        p.nBit_RtpStartsNewCodedVideoSequence = (0, common_js_1.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()
+        ]);
+    }
+}
+exports.AV1RtpPayload = AV1RtpPayload;
+class AV1Obu {
+    static deSerialize(buf) {
+        const obu = new AV1Obu();
+        let offset = 0;
+        obu.obu_forbidden_bit = (0, common_js_1.getBit)(buf[offset], 0);
+        obu.obu_type =
+            OBU_TYPES[(0, common_js_1.getBit)(buf[offset], 1, 4)];
+        obu.obu_extension_flag = (0, common_js_1.getBit)(buf[offset], 5);
+        obu.obu_has_size_field = (0, common_js_1.getBit)(buf[offset], 6);
+        obu.obu_reserved_1bit = (0, common_js_1.getBit)(buf[offset], 7);
+        offset++;
+        obu.payload = buf.subarray(offset);
+        return obu;
+    }
+    serialize() {
+        const header = new common_js_1.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 = (0, leb128_js_1.leb128encode)(this.payload.length);
+        }
+        return Buffer.concat([header, obuSize, this.payload]);
+    }
+}
+exports.AV1Obu = AV1Obu;
+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/cjs/lib/rtp/codec/base.d.ts

@@ -0,0 +1,8 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+export declare abstract class DePacketizerBase {
+    payload: Buffer;
+    fragment?: Buffer;
+    static deSerialize(_buf: Buffer, _fragment?: Buffer): DePacketizerBase;
+    static isDetectedFinalPacketInSequence(_header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DePacketizerBase = void 0;
+class DePacketizerBase {
+    static deSerialize(_buf, _fragment) {
+        return {};
+    }
+    static isDetectedFinalPacketInSequence(_header) {
+        return true;
+    }
+    get isKeyframe() {
+        return true;
+    }
+}
+exports.DePacketizerBase = DePacketizerBase;

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

@@ -0,0 +1,32 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import type { DePacketizerBase } from './base.js';
+export declare class H264RtpPayload implements DePacketizerBase {
+    /**forbidden_zero_bit */
+    f: number;
+    /**nal_ref_idc */
+    nri: number;
+    /**nal_unit_types */
+    nalUnitType: number;
+    /**start of a fragmented NAL unit */
+    s: number;
+    /**end of a fragmented NAL unit */
+    e: number;
+    r: number;
+    nalUnitPayloadType: number;
+    payload: Buffer;
+    fragment?: Buffer;
+    static deSerialize(buf: Buffer, fragment?: Buffer): H264RtpPayload;
+    private static packaging;
+    static isDetectedFinalPacketInSequence(header: RtpHeader): boolean;
+    get isKeyframe(): boolean;
+    get isPartitionHead(): boolean;
+}
+export declare const NalUnitType: {
+    readonly idrSlice: 5;
+    readonly stap_a: 24;
+    readonly stap_b: 25;
+    readonly mtap16: 26;
+    readonly mtap24: 27;
+    readonly fu_a: 28;
+    readonly fu_b: 29;
+};