@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,45 @@
+import { createHmac } from 'node:crypto';
+import type { CipherAesBase } from '../cipher/index.js';
+import { type SrtpProfile } from '../const.js';
+/** AES-128-ECB single-block encrypt for SRTP KDF (no padding). */
+export declare function aes128EcbEncrypt(key: Buffer, plaintext: Buffer): Buffer;
+export declare class Context {
+    masterKey: Buffer;
+    masterSalt: Buffer;
+    profile: SrtpProfile;
+    srtpSSRCStates: {
+        [ssrc: number]: SrtpSsrcState;
+    };
+    srtpSessionKey: Buffer;
+    srtpSessionSalt: Buffer;
+    srtpSessionAuthTag: Buffer;
+    srtpSessionAuth: ReturnType<typeof createHmac>;
+    srtcpSSRCStates: {
+        [ssrc: number]: SrtcpSSRCState;
+    };
+    srtcpSessionKey: Buffer;
+    srtcpSessionSalt: Buffer;
+    srtcpSessionAuthTag: Buffer;
+    srtcpSessionAuth: ReturnType<typeof createHmac>;
+    cipher: CipherAesBase;
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    generateSessionKey(label: number): Buffer<ArrayBufferLike>;
+    generateSessionSalt(label: number): Buffer<ArrayBufferLike>;
+    generateSessionAuthTag(label: number): Buffer<ArrayBuffer>;
+    getSrtpSsrcState(ssrc: number): SrtpSsrcState;
+    getSrtcpSsrcState(ssrc: number): SrtcpSSRCState;
+    updateRolloverCount(sequenceNumber: number, s: SrtpSsrcState): void;
+    generateSrtpAuthTag(buf: Buffer, roc: number): Buffer<ArrayBuffer>;
+    index(ssrc: number): number;
+    setIndex(ssrc: number, index: number): void;
+}
+export interface SrtpSsrcState {
+    ssrc: number;
+    rolloverCounter: number;
+    rolloverHasProcessed?: boolean;
+    lastSequenceNumber: number;
+}
+export type SrtcpSSRCState = {
+    srtcpIndex: number;
+    ssrc: number;
+};

package/dist/cjs/lib/rtp/srtp/context/context.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+exports.aes128EcbEncrypt = aes128EcbEncrypt;
+const node_crypto_1 = require("node:crypto");
+const ctr_js_1 = require("../cipher/ctr.js");
+const gcm_js_1 = require("../cipher/gcm.js");
+const const_js_1 = require("../const.js");
+/** AES-128-ECB single-block encrypt for SRTP KDF (no padding). */
+function aes128EcbEncrypt(key, plaintext) {
+    const cipher = (0, node_crypto_1.createCipheriv)('aes-128-ecb', key, null);
+    cipher.setAutoPadding(false);
+    return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+class Context {
+    constructor(masterKey, masterSalt, profile) {
+        this.masterKey = masterKey;
+        this.masterSalt = masterSalt;
+        this.profile = profile;
+        this.srtpSSRCStates = {};
+        this.srtcpSSRCStates = {};
+        {
+            // AES-ECB plaintext require 16byte
+            // so need to padding to 14 byte
+            const diff = 14 - masterSalt.length;
+            if (diff > 0) {
+                this.masterSalt = Buffer.concat([masterSalt, Buffer.alloc(diff)]);
+            }
+        }
+        this.srtpSessionKey = this.generateSessionKey(0);
+        this.srtpSessionSalt = this.generateSessionSalt(2);
+        this.srtpSessionAuthTag = this.generateSessionAuthTag(1);
+        this.srtpSessionAuth = (0, node_crypto_1.createHmac)('sha1', this.srtpSessionAuthTag);
+        this.srtcpSessionKey = this.generateSessionKey(3);
+        this.srtcpSessionSalt = this.generateSessionSalt(5);
+        this.srtcpSessionAuthTag = this.generateSessionAuthTag(4);
+        this.srtcpSessionAuth = (0, node_crypto_1.createHmac)('sha1', this.srtcpSessionAuthTag);
+        switch (profile) {
+            case const_js_1.ProtectionProfileAes128CmHmacSha1_80:
+                this.cipher = new ctr_js_1.CipherAesCtr(this.srtpSessionKey, this.srtpSessionSalt, this.srtcpSessionKey, this.srtcpSessionSalt, this.srtpSessionAuthTag, this.srtcpSessionAuthTag);
+                break;
+            case const_js_1.ProtectionProfileAeadAes128Gcm:
+                this.cipher = new gcm_js_1.CipherAesGcm(this.srtpSessionKey, this.srtpSessionSalt, this.srtcpSessionKey, this.srtcpSessionSalt);
+                break;
+        }
+    }
+    generateSessionKey(label) {
+        let sessionKey = Buffer.from(this.masterSalt);
+        const labelAndIndexOverKdr = Buffer.from([
+            label,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00
+        ]);
+        for (let i = labelAndIndexOverKdr.length - 1, j = sessionKey.length - 1; i >= 0; i--, j--) {
+            sessionKey[j] = sessionKey[j] ^ labelAndIndexOverKdr[i];
+        }
+        sessionKey = Buffer.concat([sessionKey, Buffer.from([0x00, 0x00])]);
+        return aes128EcbEncrypt(this.masterKey, sessionKey);
+    }
+    generateSessionSalt(label) {
+        let sessionSalt = Buffer.from(this.masterSalt);
+        const labelAndIndexOverKdr = Buffer.from([
+            label,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00
+        ]);
+        for (let i = labelAndIndexOverKdr.length - 1, j = sessionSalt.length - 1; i >= 0; i--, j--) {
+            sessionSalt[j] = sessionSalt[j] ^ labelAndIndexOverKdr[i];
+        }
+        sessionSalt = Buffer.concat([sessionSalt, Buffer.from([0x00, 0x00])]);
+        sessionSalt = aes128EcbEncrypt(this.masterKey, sessionSalt);
+        return sessionSalt.subarray(0, 14);
+    }
+    generateSessionAuthTag(label) {
+        const sessionAuthTag = Buffer.from(this.masterSalt);
+        const labelAndIndexOverKdr = Buffer.from([
+            label,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00
+        ]);
+        for (let i = labelAndIndexOverKdr.length - 1, j = sessionAuthTag.length - 1; i >= 0; i--, j--) {
+            sessionAuthTag[j] = sessionAuthTag[j] ^ labelAndIndexOverKdr[i];
+        }
+        let firstRun = Buffer.concat([
+            sessionAuthTag,
+            Buffer.from([0x00, 0x00])
+        ]);
+        let secondRun = Buffer.concat([
+            sessionAuthTag,
+            Buffer.from([0x00, 0x01])
+        ]);
+        firstRun = aes128EcbEncrypt(this.masterKey, firstRun);
+        secondRun = aes128EcbEncrypt(this.masterKey, secondRun);
+        return Buffer.concat([firstRun, secondRun.subarray(0, 4)]);
+    }
+    getSrtpSsrcState(ssrc) {
+        let s = this.srtpSSRCStates[ssrc];
+        if (s)
+            return s;
+        s = {
+            ssrc,
+            rolloverCounter: 0,
+            lastSequenceNumber: 0
+        };
+        this.srtpSSRCStates[ssrc] = s;
+        return s;
+    }
+    getSrtcpSsrcState(ssrc) {
+        let s = this.srtcpSSRCStates[ssrc];
+        if (s)
+            return s;
+        s = {
+            srtcpIndex: 0,
+            ssrc
+        };
+        this.srtcpSSRCStates[ssrc] = s;
+        return s;
+    }
+    // 3.3.1.  Packet Index Determination, and ROC, s_l Update
+    // In particular, out-of-order RTP packets with
+    // sequence numbers close to 2^16 or zero must be properly handled.
+    updateRolloverCount(sequenceNumber, s) {
+        if (!s.rolloverHasProcessed) {
+            s.rolloverHasProcessed = true;
+        }
+        else if (sequenceNumber === 0) {
+            if (s.lastSequenceNumber > MaxROCDisorder) {
+                s.rolloverCounter++;
+            }
+        }
+        else if (s.lastSequenceNumber < MaxROCDisorder &&
+            sequenceNumber > MaxSequenceNumber - MaxROCDisorder) {
+            // https://github.com/shinyoshiaki/werift-webrtc/issues/94
+            if (s.rolloverCounter > 0) {
+                s.rolloverCounter--;
+            }
+        }
+        else if (sequenceNumber < MaxROCDisorder &&
+            s.lastSequenceNumber > MaxSequenceNumber - MaxROCDisorder) {
+            s.rolloverCounter++;
+        }
+        s.lastSequenceNumber = sequenceNumber;
+    }
+    generateSrtpAuthTag(buf, roc) {
+        this.srtpSessionAuth = (0, node_crypto_1.createHmac)('sha1', this.srtpSessionAuthTag);
+        const rocRaw = Buffer.alloc(4);
+        rocRaw.writeUInt32BE(roc);
+        return this.srtpSessionAuth
+            .update(buf)
+            .update(rocRaw)
+            .digest()
+            .slice(0, 10);
+    }
+    index(ssrc) {
+        const s = this.srtcpSSRCStates[ssrc];
+        if (!s) {
+            return 0;
+        }
+        return s.srtcpIndex;
+    }
+    setIndex(ssrc, index) {
+        const s = this.getSrtcpSsrcState(ssrc);
+        s.srtcpIndex = index % 0x7fffffff;
+    }
+}
+exports.Context = Context;
+const MaxROCDisorder = 100;
+const MaxSequenceNumber = 65535;

package/dist/cjs/lib/rtp/srtp/context/srtcp.d.ts

@@ -0,0 +1,8 @@
+import type { RtcpHeader } from '../../rtcp/header.js';
+import type { SrtpProfile } from '../const.js';
+import { Context } from './context.js';
+export declare class SrtcpContext extends Context {
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    encryptRTCP(rawRtcp: Buffer): Buffer<ArrayBufferLike>;
+    decryptRTCP(encrypted: Buffer): [Buffer, RtcpHeader];
+}

package/dist/cjs/lib/rtp/srtp/context/srtcp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtcpContext = void 0;
+const context_js_1 = require("./context.js");
+class SrtcpContext extends context_js_1.Context {
+    constructor(masterKey, masterSalt, profile) {
+        super(masterKey, masterSalt, profile);
+    }
+    encryptRTCP(rawRtcp) {
+        const ssrc = rawRtcp.readUInt32BE(4);
+        const s = this.getSrtcpSsrcState(ssrc);
+        s.srtcpIndex++;
+        if (s.srtcpIndex >> maxSRTCPIndex) {
+            s.srtcpIndex = 0;
+        }
+        const enc = this.cipher.encryptRTCP(rawRtcp, s.srtcpIndex);
+        return enc;
+    }
+    decryptRTCP(encrypted) {
+        const dec = this.cipher.decryptRTCP(encrypted);
+        return dec;
+    }
+}
+exports.SrtcpContext = SrtcpContext;
+const maxSRTCPIndex = 0x7fffffff;

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

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../../rtp/rtp.js';
+import { type SrtpProfile } from '../const.js';
+import { Context } from './context.js';
+export declare class SrtpContext extends Context {
+    constructor(masterKey: Buffer, masterSalt: Buffer, profile: SrtpProfile);
+    encryptRtp(payload: Buffer, header: RtpHeader): Buffer<ArrayBufferLike>;
+    decryptRtp(cipherText: Buffer): [Buffer, RtpHeader];
+    private get rtpAuthTagLength();
+}

package/dist/cjs/lib/rtp/srtp/context/srtp.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtpContext = void 0;
+const const_js_1 = require("../const.js");
+const packet_js_1 = require("../packet.js");
+const context_js_1 = require("./context.js");
+class SrtpContext extends context_js_1.Context {
+    constructor(masterKey, masterSalt, profile) {
+        super(masterKey, masterSalt, profile);
+    }
+    encryptRtp(payload, header) {
+        const s = this.getSrtpSsrcState(header.ssrc);
+        this.updateRolloverCount(header.sequenceNumber, s);
+        const enc = this.cipher.encryptRtp(header, payload, s.rolloverCounter);
+        return enc;
+    }
+    decryptRtp(cipherText) {
+        const header = (0, packet_js_1.parseSrtpRtpHeader)(cipherText, this.rtpAuthTagLength);
+        const existingState = this.srtpSSRCStates[header.ssrc];
+        const nextState = existingState
+            ? { ...existingState }
+            : {
+                ssrc: header.ssrc,
+                rolloverCounter: 0,
+                lastSequenceNumber: 0
+            };
+        this.updateRolloverCount(header.sequenceNumber, nextState);
+        const dec = this.cipher.decryptRtp(cipherText, nextState.rolloverCounter, header);
+        if (existingState) {
+            Object.assign(existingState, nextState);
+        }
+        else {
+            this.srtpSSRCStates[header.ssrc] = nextState;
+        }
+        return dec;
+    }
+    get rtpAuthTagLength() {
+        return this.profile === const_js_1.ProtectionProfileAeadAes128Gcm ? 16 : 10;
+    }
+}
+exports.SrtpContext = SrtpContext;

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

@@ -0,0 +1,3 @@
+export declare class SrtpAuthenticationError extends Error {
+    constructor(message: string);
+}

package/dist/cjs/lib/rtp/srtp/error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtpAuthenticationError = void 0;
+class SrtpAuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SrtpAuthenticationError';
+    }
+}
+exports.SrtpAuthenticationError = SrtpAuthenticationError;

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

@@ -0,0 +1,5 @@
+import { RtcpHeader } from '../rtcp/header.js';
+import { RtpHeader } from '../rtp/rtp.js';
+export declare function parseSrtpRtpHeader(packet: Buffer, authTagLength: number, message?: string): RtpHeader;
+export declare function parseSrtcpHeader(packet: Buffer, authTagLength: number, srtcpIndexSize: number, message?: string): RtcpHeader;
+export declare function finalizeSrtpRtpHeader(header: RtpHeader, packet: Buffer, message?: string): RtpHeader;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSrtpRtpHeader = parseSrtpRtpHeader;
+exports.parseSrtcpHeader = parseSrtcpHeader;
+exports.finalizeSrtpRtpHeader = finalizeSrtpRtpHeader;
+const header_js_1 = require("../rtcp/header.js");
+const rtp_js_1 = require("../rtp/rtp.js");
+const error_js_1 = require("./error.js");
+const minRtpHeaderSize = 12;
+const minRtcpPacketSize = 8;
+function parseSrtpRtpHeader(packet, authTagLength, message = 'Failed to authenticate SRTP packet') {
+    const authTagOffset = packet.length - authTagLength;
+    assertAuthenticatedPacketLength(packet.length >= minRtpHeaderSize + authTagLength, message);
+    const header = wrapAuthenticationError(() => rtp_js_1.RtpHeader.deSerialize(packet.subarray(0, authTagOffset)), message);
+    header.paddingSize = 0;
+    assertAuthenticatedPacketLength(header.payloadOffset >= minRtpHeaderSize &&
+        header.payloadOffset <= authTagOffset, message);
+    return header;
+}
+function parseSrtcpHeader(packet, authTagLength, srtcpIndexSize, message = 'Failed to authenticate SRTCP packet') {
+    assertAuthenticatedPacketLength(packet.length >= minRtcpPacketSize + authTagLength + srtcpIndexSize, message);
+    return wrapAuthenticationError(() => header_js_1.RtcpHeader.deSerialize(packet.subarray(0, header_js_1.RTCP_HEADER_SIZE)), message);
+}
+function assertAuthenticatedPacketLength(condition, message) {
+    if (!condition) {
+        throw new error_js_1.SrtpAuthenticationError(message);
+    }
+}
+function wrapAuthenticationError(parse, message) {
+    try {
+        return parse();
+    }
+    catch {
+        throw new error_js_1.SrtpAuthenticationError(message);
+    }
+}
+function finalizeSrtpRtpHeader(header, packet, message = 'Failed to authenticate SRTP packet') {
+    if (!header.padding) {
+        header.paddingSize = 0;
+        return header;
+    }
+    assertAuthenticatedPacketLength(packet.length > header.payloadOffset, message);
+    const paddingSize = packet[packet.length - 1];
+    assertAuthenticatedPacketLength(paddingSize > 0 && paddingSize <= packet.length - header.payloadOffset, message);
+    header.paddingSize = paddingSize;
+    return header;
+}

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

@@ -0,0 +1,19 @@
+import type { Context } from './context/context.js';
+export type SessionKeys = {
+    localMasterKey: Buffer;
+    localMasterSalt: Buffer;
+    remoteMasterKey: Buffer;
+    remoteMasterSalt: Buffer;
+};
+export type Config = {
+    keys: SessionKeys;
+    profile: number;
+};
+export declare class Session<T extends Context> {
+    private ContextCls;
+    localContext: T;
+    remoteContext: T;
+    onData?: (buf: Buffer) => void;
+    constructor(ContextCls: any);
+    start(localMasterKey: Buffer, localMasterSalt: Buffer, remoteMasterKey: Buffer, remoteMasterSalt: Buffer, profile: number): void;
+}

package/dist/cjs/lib/rtp/srtp/session.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+class Session {
+    constructor(ContextCls) {
+        this.ContextCls = ContextCls;
+    }
+    start(localMasterKey, localMasterSalt, remoteMasterKey, remoteMasterSalt, profile) {
+        this.localContext = new this.ContextCls(localMasterKey, localMasterSalt, profile);
+        this.remoteContext = new this.ContextCls(remoteMasterKey, remoteMasterSalt, profile);
+    }
+}
+exports.Session = Session;

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

@@ -0,0 +1,8 @@
+import { SrtcpContext } from './context/srtcp.js';
+import { type Config, Session } from './session.js';
+export declare class SrtcpSession extends Session<SrtcpContext> {
+    config: Config;
+    constructor(config: Config);
+    decrypt: (buf: Buffer) => Buffer<ArrayBufferLike>;
+    encrypt(rawRtcp: Buffer): Buffer<ArrayBufferLike>;
+}

package/dist/cjs/lib/rtp/srtp/srtcp.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtcpSession = void 0;
+const srtcp_js_1 = require("./context/srtcp.js");
+const session_js_1 = require("./session.js");
+class SrtcpSession extends session_js_1.Session {
+    constructor(config) {
+        super(srtcp_js_1.SrtcpContext);
+        this.config = config;
+        this.decrypt = (buf) => {
+            const [decrypted] = this.remoteContext.decryptRTCP(buf);
+            return decrypted;
+        };
+        this.start(config.keys.localMasterKey, config.keys.localMasterSalt, config.keys.remoteMasterKey, config.keys.remoteMasterSalt, config.profile);
+    }
+    encrypt(rawRtcp) {
+        const enc = this.localContext.encryptRTCP(rawRtcp);
+        return enc;
+    }
+}
+exports.SrtcpSession = SrtcpSession;

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

@@ -0,0 +1,9 @@
+import type { RtpHeader } from '../rtp/rtp.js';
+import { SrtpContext } from './context/srtp.js';
+import { type Config, Session } from './session.js';
+export declare class SrtpSession extends Session<SrtpContext> {
+    config: Config;
+    constructor(config: Config);
+    decrypt: (buf: Buffer) => Buffer<ArrayBufferLike>;
+    encrypt(payload: Buffer, header: RtpHeader): Buffer<ArrayBufferLike>;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SrtpSession = void 0;
+const srtp_js_1 = require("./context/srtp.js");
+const session_js_1 = require("./session.js");
+class SrtpSession extends session_js_1.Session {
+    constructor(config) {
+        super(srtp_js_1.SrtpContext);
+        this.config = config;
+        this.decrypt = (buf) => {
+            const [decrypted] = this.remoteContext.decryptRtp(buf);
+            return decrypted;
+        };
+        this.start(config.keys.localMasterKey, config.keys.localMasterSalt, config.keys.remoteMasterKey, config.keys.remoteMasterSalt, config.profile);
+    }
+    encrypt(payload, header) {
+        return this.localContext.encryptRtp(payload, header);
+    }
+}
+exports.SrtpSession = SrtpSession;

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

@@ -0,0 +1,15 @@
+import type { RemoteInfo, Socket } from 'node:dgram';
+export interface Transport {
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => void;
+    close: () => void;
+}
+export declare class UdpTransport implements Transport {
+    private upd;
+    private rinfo;
+    constructor(upd: Socket, rinfo: Partial<RemoteInfo>);
+    onData?: (buf: Buffer) => void;
+    send(buf: Buffer): void;
+    close(): void;
+}
+export declare const createUdpTransport: (socket: Socket, rinfo?: Partial<RemoteInfo>) => UdpTransport;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUdpTransport = exports.UdpTransport = void 0;
+class UdpTransport {
+    constructor(upd, rinfo) {
+        this.upd = upd;
+        this.rinfo = rinfo;
+        upd.on('message', (buf, target) => {
+            this.rinfo = target;
+            if (this.onData)
+                this.onData(buf);
+        });
+    }
+    send(buf) {
+        this.upd.send(buf, this.rinfo.port, this.rinfo.address);
+    }
+    close() {
+        this.upd.close();
+    }
+}
+exports.UdpTransport = UdpTransport;
+const createUdpTransport = (socket, rinfo = {}) => new UdpTransport(socket, rinfo);
+exports.createUdpTransport = createUdpTransport;

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

@@ -0,0 +1,11 @@
+import { RtpPacket } from './rtp/rtp.js';
+export declare class RtpBuilder {
+    private props;
+    sequenceNumber: number;
+    timestamp: number;
+    constructor(props: {
+        between: number;
+        clockRate: number;
+    });
+    create(payload: Buffer): RtpPacket;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtpBuilder = void 0;
+const index_js_1 = require("../common/index.js");
+const rtp_js_1 = require("./rtp/rtp.js");
+class RtpBuilder {
+    constructor(props) {
+        this.props = props;
+        this.sequenceNumber = (0, index_js_1.random16)();
+        this.timestamp = (0, index_js_1.random32)();
+    }
+    create(payload) {
+        this.sequenceNumber = (0, index_js_1.uint16Add)(this.sequenceNumber, 1);
+        const elapsed = (this.props.between * this.props.clockRate) / 1000;
+        this.timestamp = (0, index_js_1.uint32Add)(this.timestamp, elapsed);
+        const header = new rtp_js_1.RtpHeader({
+            sequenceNumber: this.sequenceNumber,
+            timestamp: Number(this.timestamp),
+            payloadType: 96,
+            extension: true,
+            marker: false,
+            padding: false
+        });
+        const rtp = new rtp_js_1.RtpPacket(header, payload);
+        return rtp;
+    }
+}
+exports.RtpBuilder = RtpBuilder;