@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/peer/Endpoints.js

@@ -0,0 +1,143 @@
+import { randomBytes } from 'node:crypto';
+/**
+ * How long an answer of an HTTP endpoint (WHIP, WHEP) waits for the candidates of its connection at most, in
+ * milliseconds
+ */
+export const GATHERING_TIMEOUT = 5000;
+/**
+ * Wait for the candidates of a connection, all of them or for a time at most
+ * @param connection
+ * @param timeout
+ */
+export function gathered(connection, timeout = GATHERING_TIMEOUT) {
+    if (connection.iceGatheringState === 'complete')
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            connection.off('icegatheringstatechange', changed);
+            resolve();
+        };
+        const changed = (state) => {
+            if (state === 'complete')
+                done();
+        };
+        const timer = setTimeout(done, timeout);
+        connection.on('icegatheringstatechange', changed);
+    });
+}
+/**
+ * The bearer token of a request
+ * @param request
+ */
+export function bearerOf(request) {
+    return /^Bearer\s+(\S+)\s*$/i.exec(request.headers.authorization ?? '')?.[1];
+}
+/**
+ * The path of a request, without its query and its last slash
+ * @param request
+ */
+export function pathOf(request) {
+    const url = request.originalUrl ?? request.url ?? '';
+    return url.split('?')[0].replace(/\/+$/, '');
+}
+/**
+ * A `Link` header of each ICE server (RFC 9725, section 4.6)
+ * @param iceServers
+ */
+export function linksOf(iceServers) {
+    const quoted = (value) => `"${value.replace(/["\\]/g, '\\$&')}"`;
+    return iceServers.flatMap((server) => (Array.isArray(server.urls) ? server.urls : [server.urls]).map((url) => {
+        const credentials = server.username && server.credential
+            ? `; username=${quoted(server.username)}; credential=${quoted(server.credential)}; credential-type="password"`
+            : '';
+        return `<${url}>; rel="ice-server"${credentials}`;
+    }));
+}
+/**
+ * The ICE of a fragment of SDP (RFC 8840): its credentials, and its candidates with the media they belong to
+ * @param fragment
+ */
+export function iceOf(fragment) {
+    const ice = { candidates: [] };
+    //The session, then each media: the candidates of a media are of its mid, before or after them
+    for (const section of fragment.split(/^(?=m=)/m)) {
+        const lines = section.split(/\r?\n/);
+        const mid = lines.find((line) => line.startsWith('a=mid:'))?.slice('a=mid:'.length).trim();
+        for (const line of lines) {
+            if (line.startsWith('a=ice-ufrag:'))
+                ice.ufrag ??= line.slice('a=ice-ufrag:'.length).trim();
+            else if (line.startsWith('a=ice-pwd:'))
+                ice.pwd ??= line.slice('a=ice-pwd:'.length).trim();
+            else if (line.startsWith('a=candidate:'))
+                ice.candidates.push({ candidate: line.slice(2).trim(), ...mid === undefined ? {} : { sdpMid: mid } });
+        }
+    }
+    return ice;
+}
+/**
+ * Apply a PATCH of a session of an HTTP endpoint (RFC 9725, section 4.3) to its connection: the candidates of the
+ * client (trickle ICE), or an ICE restart when its credentials changed. The server answering the offer of the client,
+ * a restart is an offer of the client again, its credentials replaced, that the connection answers with new ones.
+ * @param connection
+ * @param fragment The fragment of SDP of the request (`application/trickle-ice-sdpfrag`).
+ * @param restart Whether the request may restart ICE (its `If-Match` is `*`): a fragment of other credentials without
+ * it is of an ICE session gone (a request sent again after a restart), not applied.
+ * @returns The fragment of the answer of a restart (its credentials, its candidates); none for trickle ICE; `null` for
+ * a fragment of an ICE session gone.
+ * @throws {Error} When the fragment has no ICE, or the connection refuses it.
+ */
+export async function patchConnection(connection, fragment, restart) {
+    const ice = iceOf(fragment);
+    const remote = connection.remoteDescription?.sdp ?? '';
+    const mids = [...remote.matchAll(/^a=mid:(\S+)/gm)].map((match) => match[1]);
+    const add = async () => {
+        for (const { candidate, sdpMid } of ice.candidates)
+            await connection.addIceCandidate({ candidate: candidate, sdpMid: sdpMid ?? mids[0] ?? null });
+    };
+    const restarting = !!ice.ufrag && ice.ufrag !== /^a=ice-ufrag:(\S+)/m.exec(remote)?.[1];
+    if (restarting && !restart)
+        return null;
+    if (!restarting) {
+        //The end of the candidates of the client has nothing to apply
+        if (!ice.ufrag && !ice.candidates.length && !/^a=end-of-candidates/m.test(fragment))
+            throw new Error('The fragment has no ICE');
+        await add();
+        return undefined;
+    }
+    if (!ice.pwd)
+        throw new Error('The fragment of an ICE restart has no password');
+    const offer = remote
+        .replace(/^a=ice-ufrag:.*$/gm, `a=ice-ufrag:${ice.ufrag}`)
+        .replace(/^a=ice-pwd:.*$/gm, `a=ice-pwd:${ice.pwd}`)
+        .replace(/^a=(candidate:.*|end-of-candidates)\r?\n/gm, '');
+    await connection.setRemoteDescription({ type: 'offer', sdp: offer });
+    await connection.setLocalDescription();
+    await add();
+    await gathered(connection);
+    return fragmentOf(connection.localDescription?.sdp ?? '');
+}
+/**
+ * The fragment of SDP of the ICE of a description (RFC 8840): its credentials, and the candidates of its first media
+ * (the one the others are bundled on)
+ * @param sdp
+ */
+export function fragmentOf(sdp) {
+    const first = (sdp.split(/^(?=m=)/m)[1] ?? '').split(/\r?\n/);
+    return [
+        `a=ice-ufrag:${/^a=ice-ufrag:(\S+)/m.exec(sdp)?.[1] ?? ''}`,
+        `a=ice-pwd:${/^a=ice-pwd:(\S+)/m.exec(sdp)?.[1] ?? ''}`,
+        ...first[0] ? [
+            first[0],
+            ...first.filter((line) => line.startsWith('a=mid:')),
+            ...first.filter((line) => line.startsWith('a=candidate:')),
+            'a=end-of-candidates'
+        ] : []
+    ].join('\r\n') + '\r\n';
+}
+/**
+ * A new entity tag of an ICE session (the `ETag` of a session of an HTTP endpoint)
+ */
+export function entityTag() {
+    return randomBytes(12).toString('hex');
+}

package/dist/esm/peer/EngineConfig.js

@@ -0,0 +1,33 @@
+import { useTWCC } from '../lib/peer/media/extension/rtcpFeedback.js';
+import { useAbsSendTime, useAudioLevelIndication, useSdesMid, useTransportWideCC } from '../lib/peer/media/extension/rtpExtension.js';
+import { engineCodecsOf } from './MediaCodecs.js';
+/**
+ * The configuration of the connection of the engine of a connection
+ * @param options
+ */
+export function engineConfigOf(options) {
+    const config = {
+        iceServers: options.iceServers,
+        iceTransportPolicy: options.iceTransportPolicy,
+        iceUseIpv4: options.iceUseIpv4,
+        iceUseIpv6: options.iceUseIpv6,
+        codecs: engineCodecsOf(options.codecs),
+        //The largest message the other peer may send, as Chrome accepts (below the SCTP window of 1 MiB)
+        maxMessageSize: 262144
+    };
+    if (options.icePortRange)
+        config.icePortRange = options.icePortRange;
+    if (options.iceAdditionalHostAddresses)
+        config.iceAdditionalHostAddresses = options.iceAdditionalHostAddresses;
+    if (options.headerExtensions) {
+        //The ids of Chrome and Safari: a browser rolling back an offer of its own keeps its ids, and refuses others
+        config.headerExtensions = {
+            audio: [useAudioLevelIndication(), useAbsSendTime(), useTransportWideCC(), useSdesMid()],
+            video: [useAbsSendTime(), useTransportWideCC(), useSdesMid()]
+        };
+        //The feedback of the transport-wide sequence numbers
+        for (const codec of [...config.codecs.audio, ...config.codecs.video])
+            codec.rtcpFeedback.push(useTWCC());
+    }
+    return config;
+}

package/dist/esm/peer/EngineConnection.js

@@ -0,0 +1,22 @@
+/**
+ * The connections of the engine of the connections
+ */
+export const engineConnections = new WeakMap();
+/**
+ * The connection of the engine of a connection: its transports, its senders and receivers
+ * @param connection
+ */
+export function engineConnectionOf(connection) {
+    return engineConnections.get(connection);
+}
+/**
+ * The channels of the engine of the channels
+ */
+export const engineChannels = new WeakMap();
+/**
+ * The channel of the engine of a channel: its SCTP transport
+ * @param channel
+ */
+export function engineChannelOf(channel) {
+    return engineChannels.get(channel);
+}

package/dist/esm/peer/Events.js

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'node:events';
+/**
+ * The events of an object, in the two styles of the peer connections and of the channels: the W3C style
+ * (`addEventListener`, the `on…` properties, given an event object) and the Node.js style (`on`, given the value of the
+ * event)
+ */
+export class Events {
+    #target = new EventTarget();
+    #emitter = new EventEmitter();
+    #handlers = new Map();
+    #owner;
+    /**
+     * The events of an object
+     * @param owner
+     */
+    constructor(owner) {
+        this.#owner = owner;
+        //More listeners than the warning threshold of Node.js are expected (a channel per peer…)
+        this.#emitter.setMaxListeners(0);
+    }
+    /**
+     * Fire an event: the listeners of the W3C style get an event object holding the given properties, the ones of the
+     * Node.js style get the arguments
+     * @param type
+     * @param properties
+     * @param args
+     */
+    fire(type, properties, ...args) {
+        const event = type === 'message' ? new MessageEvent('message', { data: properties.data }) : new Event(type);
+        for (const [key, value] of Object.entries(properties)) {
+            if (key !== 'data')
+                Object.defineProperty(event, key, { value: value, enumerable: true });
+        }
+        Object.defineProperty(event, 'currentTarget', { value: this.#owner });
+        this.#target.dispatchEvent(event);
+        const handler = this.#handlers.get(type);
+        if (handler)
+            handler.call(this.#owner, event);
+        //An error without listeners would throw
+        if (type !== 'error' || this.#emitter.listenerCount('error'))
+            this.#emitter.emit(type, ...args);
+    }
+    /**
+     * Dispatch an event given: the listeners of the W3C style get it, the ones of the Node.js style the arguments
+     * @param event
+     * @param args
+     */
+    dispatch(event, ...args) {
+        const dispatched = this.#target.dispatchEvent(event);
+        this.#handlers.get(event.type)?.call(this.#owner, event);
+        if (event.type !== 'error' || this.#emitter.listenerCount('error'))
+            this.#emitter.emit(event.type, ...args);
+        return dispatched && !event.defaultPrevented;
+    }
+    addEventListener(type, listener, options) {
+        this.#target.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, options) {
+        this.#target.removeEventListener(type, listener, options);
+    }
+    on(type, listener) {
+        this.#emitter.on(type, listener);
+    }
+    once(type, listener) {
+        this.#emitter.once(type, listener);
+    }
+    off(type, listener) {
+        this.#emitter.off(type, listener);
+    }
+    handler(type) {
+        return this.#handlers.get(type) ?? null;
+    }
+    setHandler(type, handler) {
+        if (handler) {
+            this.#handlers.set(type, handler);
+        }
+        else {
+            this.#handlers.delete(type);
+        }
+    }
+}

package/dist/esm/peer/MediaCodecs.js

@@ -0,0 +1,47 @@
+import { useH264, useOPUS, usePCMU, useVP8, useVP9 } from '../lib/peer/media/codec.js';
+/**
+ * The codecs the connections negotiate, by their MIME type in lower case
+ */
+const CODECS = {
+    'audio/opus': () => useOPUS(),
+    'audio/pcmu': () => usePCMU(),
+    'video/vp8': () => useVP8(),
+    'video/vp9': () => useVP9(),
+    'video/h264': () => useH264()
+};
+/**
+ * The MIME types of the codecs supported
+ */
+export const SUPPORTED_CODECS = ['audio/opus', 'audio/PCMU', 'video/VP8', 'video/VP9', 'video/H264'];
+/**
+ * The codecs offered by default, in the order of preference: the ones of the browsers, VP8 first as Chrome does
+ */
+export const DEFAULT_CODECS = ['audio/opus', 'audio/PCMU', 'video/VP8', 'video/H264', 'video/VP9'];
+/**
+ * The MIME type of a codec as written in SUPPORTED_CODECS (`video/H264`, `audio/opus`), whatever its case
+ * @param mimeType
+ */
+export function canonicalCodec(mimeType) {
+    return SUPPORTED_CODECS.find((codec) => codec.toLowerCase() === mimeType.toLowerCase()) ?? mimeType;
+}
+/**
+ * The codec of the engine of a MIME type
+ * @param mimeType
+ */
+export function engineCodecOf(mimeType) {
+    const codec = CODECS[mimeType.toLowerCase()];
+    if (!codec)
+        throw new TypeError(`The codec ${mimeType} is not supported: ${SUPPORTED_CODECS.join(', ')}`);
+    return codec();
+}
+/**
+ * The codecs of the engine of a list of MIME types, by kind
+ * @param mimeTypes
+ */
+export function engineCodecsOf(mimeTypes) {
+    const codecs = mimeTypes.map(engineCodecOf);
+    return {
+        audio: codecs.filter((codec) => codec.mimeType.toLowerCase().startsWith('audio/')),
+        video: codecs.filter((codec) => codec.mimeType.toLowerCase().startsWith('video/'))
+    };
+}

package/dist/esm/peer/MediaTrack.js

@@ -0,0 +1,305 @@
+import { EventEmitter } from 'node:events';
+import { MediaStreamTrack } from '../lib/peer/media/track.js';
+import { canonicalCodec, engineCodecOf } from './MediaCodecs.js';
+import { RtpPacket, enginePacketOf, rtpPacketOf } from './RtpPacket.js';
+/**
+ * The tracks of the tracks of the engine
+ */
+const tracks = new WeakMap();
+/**
+ * The tracks of the engine of the tracks
+ */
+const engineTracks = new WeakMap();
+/**
+ * The events of the tracks
+ */
+const emitters = new WeakMap();
+/**
+ * The receivers of the received tracks
+ */
+const receivers = new WeakMap();
+/**
+ * Where the key frame requests of the received tracks whose packets come from elsewhere go
+ */
+const keyFrameRequesters = new WeakMap();
+/**
+ * When the key frame requests of a received track were sent on last
+ */
+const keyFrameRequests = new WeakMap();
+/**
+ * How often a received track asks its sender for a key frame at most, when the peers it is sent on to ask for some (ms)
+ */
+const KEY_FRAME_REQUEST_INTERVAL = 500;
+/**
+ * The track of the engine being wrapped by the constructor
+ */
+let adopted;
+/**
+ * An audio or video track of a {@link PeerConnection}: the RTP packets of encoded audio or video. Node.js captures and
+ * encodes nothing: a track to send gets the packets of an encoder (ffmpeg, GStreamer sending RTP to a UDP port) with
+ * `writeRtp()`, a received track gives the packets of the other peer (its `rtp` event), to record, to decode, or to send
+ * on: a received track added to another connection forwards its packets there.
+ *
+ * Create one to send with `new MediaTrack(kind, options)`, and add it with `PeerConnection.addTrack()`; the received
+ * ones come with the `track` event of the connection. Its events are in the Node.js style (`on`).
+ * @example
+ * ```typescript
+ * import {createSocket, type Socket} from 'node:dgram'
+ * import {MediaTrack, type PeerConnection} from '@lakutata/webrtc'
+ *
+ * declare const connection: PeerConnection
+ * //ffmpeg -re -i camera.mp4 -an -c:v libx264 -profile:v baseline -pix_fmt yuv420p -tune zerolatency -g 30
+ * //       -bsf:v dump_extra=freq=keyframe -f rtp rtp://127.0.0.1:5004
+ * const video: MediaTrack = new MediaTrack('video', {codec: 'video/H264'})
+ * connection.addTrack(video, 'camera')
+ * const socket: Socket = createSocket('udp4')
+ * socket.on('message', (datagram: Buffer): void => video.writeRtp(datagram))
+ * socket.bind(5004)
+ * ```
+ */
+export class MediaTrack {
+    #track;
+    #id;
+    #events = new EventEmitter();
+    #unsubscribe;
+    /**
+     * Create a track to send.
+     * @param kind `audio` or `video`.
+     * @param options The codec of the packets written, the id.
+     */
+    constructor(kind, options = {}) {
+        const track = adopted ?? new MediaStreamTrack({ kind: kind, codec: options.codec ? engineCodecOf(options.codec) : undefined });
+        if (options.codec && !track.codec?.mimeType.toLowerCase().startsWith(`${kind}/`))
+            throw new TypeError(`The codec ${options.codec} is not one of ${kind}`);
+        this.#track = track;
+        this.#id = options.id ?? track.id ?? track.uuid;
+        this.#events.setMaxListeners(0);
+        tracks.set(track, this);
+        engineTracks.set(this, track);
+        emitters.set(this, this.#events);
+        track.on('ended', () => void this.#events.emit('ended'));
+        //The packets are read (and wrapped) only while the rtp event has listeners
+        this.#events.on('newListener', (event) => {
+            if (event === 'rtp' && !this.#unsubscribe)
+                this.#unsubscribe = this.#track.onReceiveRtp.subscribe((packet, _extensions) => {
+                    if (this.#track.remote)
+                        this.#events.emit('rtp', rtpPacketOf(packet));
+                }).unSubscribe;
+        });
+        this.#events.on('removeListener', (event) => {
+            if (event === 'rtp' && !this.#events.listenerCount('rtp')) {
+                this.#unsubscribe?.();
+                this.#unsubscribe = undefined;
+            }
+        });
+    }
+    /**
+     * The id of the track.
+     */
+    get id() {
+        return this.#id;
+    }
+    /**
+     * `audio` or `video`.
+     */
+    get kind() {
+        return this.#track.kind;
+    }
+    /**
+     * Whether the track was received from the other peer.
+     */
+    get remote() {
+        return this.#track.remote;
+    }
+    /**
+     * `live`, or `ended` once stopped.
+     */
+    get readyState() {
+        return this.#track.readyState;
+    }
+    /**
+     * The MIME type of the codec of the packets: the one negotiated, the one given to a track to send; `undefined` until
+     * known.
+     */
+    get codec() {
+        const mimeType = this.#track.codec?.mimeType;
+        return mimeType ? canonicalCodec(mimeType) : undefined;
+    }
+    /**
+     * Send a packet to the peers the track is added to. The synchronization source and the payload type are the ones of
+     * each connection, the sequence numbers and the timestamps go on from the ones written before.
+     * @param packet A packet, or the bytes of one.
+     * @throws {Error} When the track was received (it is not sent from here).
+     * @example
+     * ```typescript
+     * import {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const opusFrame: Buffer
+     * const audio: MediaTrack = new MediaTrack('audio', {codec: 'audio/opus'})
+     * audio.writeRtp(new RtpPacket({payloadType: 111, sequenceNumber: 1, timestamp: 960, payload: opusFrame}))
+     * ```
+     */
+    writeRtp(packet) {
+        if (packet instanceof RtpPacket) {
+            this.#track.writeRtp(enginePacketOf(packet));
+        }
+        else {
+            this.#track.writeRtp(Buffer.isBuffer(packet) ? packet : Buffer.from(packet.buffer, packet.byteOffset, packet.byteLength));
+        }
+    }
+    /**
+     * Ask the other peer for a key frame (a picture loss indication), for the packets of a received video track to be
+     * decodable from now on: when they start to be recorded or decoded. Nothing is sent for a track to send.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * //The recording starts: from a key frame
+     * received.requestKeyFrame()
+     * ```
+     */
+    requestKeyFrame() {
+        const requester = keyFrameRequesters.get(this);
+        if (requester)
+            return requester();
+        const receiver = receivers.get(this);
+        const ssrc = this.#track.ssrc;
+        if (receiver && ssrc !== undefined)
+            void receiver.sendRtcpPLI(ssrc);
+    }
+    /**
+     * Stop the track: it is sent no more, and receives no more.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const video: MediaTrack
+     * video.stop()
+     * ```
+     */
+    stop() {
+        this.#track.stop();
+    }
+    /**
+     * Add a listener of an event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * received.on('rtp', (packet: RtpPacket): void => console.log(packet.sequenceNumber, packet.payload.length))
+     * ```
+     */
+    on(event, listener) {
+        this.#events.on(event, listener);
+        return this;
+    }
+    /**
+     * Add a listener of the next emission of an event.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * received.once('ended', (): void => console.log('the track ended'))
+     * ```
+     */
+    once(event, listener) {
+        this.#events.once(event, listener);
+        return this;
+    }
+    /**
+     * Remove a listener added with `on` or `once`.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns The track.
+     * @example
+     * ```typescript
+     * import type {MediaTrack, RtpPacket} from '@lakutata/webrtc'
+     *
+     * declare const received: MediaTrack
+     * const listener = (packet: RtpPacket): void => console.log(packet.timestamp)
+     * received.on('rtp', listener)
+     * received.off('rtp', listener)
+     * ```
+     */
+    off(event, listener) {
+        this.#events.off(event, listener);
+        return this;
+    }
+}
+/**
+ * The track of a track of the engine, created once
+ * @param track
+ * @param receiver The receiver of a received track
+ */
+export function trackOf(track, receiver) {
+    let wrapped = tracks.get(track);
+    if (!wrapped) {
+        adopted = track;
+        try {
+            wrapped = new MediaTrack(track.kind);
+        }
+        finally {
+            adopted = undefined;
+        }
+    }
+    if (receiver)
+        receivers.set(wrapped, receiver);
+    return wrapped;
+}
+/**
+ * The track of the engine of a track
+ * @param track
+ */
+export function engineTrackOf(track) {
+    return engineTracks.get(track);
+}
+/**
+ * A peer the track is sent to asks for a key frame: a received track asks its own sender (at most every
+ * KEY_FRAME_REQUEST_INTERVAL)
+ * @param track
+ */
+export function keyFrameRequested(track) {
+    emitters.get(track).emit('keyframerequest');
+    if (!track.remote)
+        return;
+    const now = Date.now();
+    if (now - (keyFrameRequests.get(track) ?? 0) < KEY_FRAME_REQUEST_INTERVAL)
+        return;
+    keyFrameRequests.set(track, now);
+    track.requestKeyFrame();
+}
+/**
+ * A received track whose packets come from elsewhere (a track of a room of the media server forwarded in a worker
+ * thread): it is read and sent on like the others, its key frame requests go back where its packets come from, which is
+ * told whether they are wanted (read, or sent on) as this changes
+ * @param kind
+ * @param codec The codec of its packets, once known.
+ * @param id The id of the track where the packets come from (a random one without it).
+ * @param source Asks for a key frame; is told whether the packets are wanted.
+ */
+export function relayedTrack(kind, codec, id, source) {
+    const engine = new MediaStreamTrack({ kind: kind, codec: codec, remote: true, ...id === undefined ? {} : { id: id } });
+    const track = trackOf(engine);
+    keyFrameRequesters.set(track, source.requestKeyFrame);
+    //The engine track reads its own packets: the others read them for something
+    const own = engine.onReceiveRtp.length;
+    let wanted = false;
+    engine.onReceiveRtp.onsubscriberschange = () => {
+        const now = !engine.stopped && engine.onReceiveRtp.length > own;
+        if (now !== wanted)
+            source.wanted(wanted = now);
+    };
+    return {
+        track: track,
+        receive: (packet, extensions) => engine.onReceiveRtp.execute(packet, extensions)
+    };
+}