@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/peer/PeerThreadChannel.d.ts

@@ -0,0 +1,112 @@
+/**
+ * What a side posts to and reads from: the parent port of a worker thread, or the worker
+ */
+export interface PeerThreadPort {
+    postMessage(value: unknown, transfer?: readonly ArrayBuffer[]): void;
+    on(event: 'message', listener: (value: unknown) => void): unknown;
+}
+/**
+ * The size below which the copies of messages and packets sent together share buffers (one allocation for many, rather
+ * than one each); the side reading them copies them into buffers of their own (of the pool of Node.js), so a message
+ * kept does not keep the others
+ */
+export declare const PACKED_SIZE: number;
+/**
+ * The bytes of a message or a packet read: a buffer of its own, copied from a shared one
+ * @param bytes
+ */
+export declare function readBytes(bytes: Uint8Array): Buffer;
+/**
+ * The bytes of RTP packets of a connection on their way to the other side at most, in each direction: beyond, the next
+ * ones are dropped, as a full UDP buffer would (the packets of the channels are not: their receive window waits)
+ */
+export declare const RTP_IN_FLIGHT: number;
+/**
+ * An error sent to the other side: its class is lost, its name and message are kept
+ */
+export interface PeerThreadError {
+    readonly name: string;
+    readonly message: string;
+}
+/**
+ * The error of the other side, with its name (InvalidStateError, OperationError…)
+ * @param error
+ */
+export declare function threadErrorOf(error: PeerThreadError): Error;
+/**
+ * An error, as sent to the other side
+ * @param error
+ */
+export declare function sentError(error: unknown): PeerThreadError;
+/**
+ * The messages of a side to the other, sent together once per turn of the event loop and in their order (requests,
+ * replies, events, data), with the buffers given transferred. A request is answered by the result of its handler, or
+ * by its error
+ */
+export declare class PeerThreadChannel<Out extends {
+    type: string;
+}, In extends {
+    type: string;
+}> {
+    #private;
+    /**
+     * Read the messages of a port.
+     * @param port The port.
+     * @param handle Handles a message; the result of a request (or its promise) is its reply.
+     */
+    constructor(port: PeerThreadPort, handle: (message: In) => unknown);
+    /**
+     * Whether the channel is closed.
+     */
+    get closed(): boolean;
+    /**
+     * Send a message that is not answered.
+     * @param message The message.
+     * @param transfer The buffers given to the other side (allocated by the sender for it: never one shared).
+     */
+    post(message: Out, transfer?: ArrayBuffer[]): void;
+    /**
+     * A copy of bytes to send with this sending: in a buffer shared with the other small ones, transferred once.
+     * @param data The bytes.
+     * @returns The copy, and the buffer to transfer with the message holding it.
+     */
+    pack(data: Uint8Array): {
+        bytes: Uint8Array;
+        transfer?: ArrayBuffer[];
+    };
+    /**
+     * Add to the last message waiting when it is one of the same kind (the messages of a channel, the packets of a
+     * track, sent together: one message for many is much cheaper to send), else send a new one; the order holds.
+     * @param extend Adds to the last message waiting, when it may: whether it did.
+     * @param message The new message, else.
+     * @param transfer The buffers given to the other side.
+     */
+    postOrExtend(extend: (last: Out) => boolean, message: () => Out, transfer?: ArrayBuffer[]): void;
+    /**
+     * Send a request, and wait for its reply.
+     * @param message The request.
+     * @param transfer The buffers given to the other side.
+     * @returns Its result.
+     * @throws {Error} The error of the other side, or the one the channel closed with.
+     */
+    request<Result>(message: Out, transfer?: ArrayBuffer[]): Promise<Result>;
+    /**
+     * Call a function before each sending.
+     * @param callback The function: it posts what changed.
+     */
+    beforeSending(callback: () => void): void;
+    /**
+     * Send at the end of this turn of the event loop, even with no message waiting: what the callbacks given to
+     * beforeSending post.
+     */
+    schedule(): void;
+    /**
+     * Send what is waiting now, without waiting for the end of the turn of the event loop.
+     */
+    flush(): void;
+    /**
+     * Close the channel: the requests waiting and the next ones fail, nothing is sent any more.
+     * @param error Their error.
+     */
+    close(error: Error): void;
+}

package/dist/cjs/peer/PeerThreadChannel.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerThreadChannel = exports.RTP_IN_FLIGHT = exports.PACKED_SIZE = void 0;
+exports.readBytes = readBytes;
+exports.threadErrorOf = threadErrorOf;
+exports.sentError = sentError;
+const log_js_1 = require("../lib/common/log.js");
+const log = (0, log_js_1.debug)('webrtc/peer/threads');
+/**
+ * The size below which the copies of messages and packets sent together share buffers (one allocation for many, rather
+ * than one each); the side reading them copies them into buffers of their own (of the pool of Node.js), so a message
+ * kept does not keep the others
+ */
+exports.PACKED_SIZE = 4096;
+/**
+ * The size of the buffers shared by the copies
+ */
+const CHUNK_SIZE = 65536;
+/**
+ * The bytes of a message or a packet read: a buffer of its own, copied from a shared one
+ * @param bytes
+ */
+function readBytes(bytes) {
+    return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+        ? Buffer.from(bytes.buffer, 0, bytes.byteLength)
+        : Buffer.from(bytes);
+}
+/**
+ * The bytes of RTP packets of a connection on their way to the other side at most, in each direction: beyond, the next
+ * ones are dropped, as a full UDP buffer would (the packets of the channels are not: their receive window waits)
+ */
+exports.RTP_IN_FLIGHT = 2 * 1024 * 1024;
+/**
+ * A copy of bytes in a buffer of its own, transferred to the other side (a view of a buffer would send all of it)
+ * @param data
+ */
+function ownCopy(data) {
+    const bytes = new Uint8Array(data);
+    return { bytes: bytes, transfer: [bytes.buffer] };
+}
+/**
+ * The error of the other side, with its name (InvalidStateError, OperationError…)
+ * @param error
+ */
+function threadErrorOf(error) {
+    return Object.assign(new Error(error.message), { name: error.name });
+}
+/**
+ * An error, as sent to the other side
+ * @param error
+ */
+function sentError(error) {
+    return error instanceof Error ? { name: error.name, message: error.message } : { name: 'Error', message: String(error) };
+}
+/**
+ * The messages of a side to the other, sent together once per turn of the event loop and in their order (requests,
+ * replies, events, data), with the buffers given transferred. A request is answered by the result of its handler, or
+ * by its error
+ */
+class PeerThreadChannel {
+    #port;
+    #handle;
+    #pending = new Map();
+    //Called before each sending, to add what a turn of the event loop changed (the amounts buffered)
+    #flushing = new Set();
+    #queue = [];
+    #transfer = [];
+    #scheduled = false;
+    #next = 1;
+    #closed;
+    //The buffer the copies of small messages and packets of this sending share, and its bytes used
+    #chunk;
+    #used = 0;
+    /**
+     * Read the messages of a port.
+     * @param port The port.
+     * @param handle Handles a message; the result of a request (or its promise) is its reply.
+     */
+    constructor(port, handle) {
+        this.#port = port;
+        this.#handle = handle;
+        port.on('message', (batch) => {
+            if (!Array.isArray(batch))
+                return;
+            for (const item of batch)
+                this.#read(item);
+        });
+    }
+    /**
+     * Whether the channel is closed.
+     */
+    get closed() {
+        return !!this.#closed;
+    }
+    /**
+     * Send a message that is not answered.
+     * @param message The message.
+     * @param transfer The buffers given to the other side (allocated by the sender for it: never one shared).
+     */
+    post(message, transfer) {
+        if (this.#closed)
+            return;
+        this.#queue.push(message);
+        if (transfer)
+            this.#transfer.push(...transfer);
+        this.#schedule();
+    }
+    /**
+     * A copy of bytes to send with this sending: in a buffer shared with the other small ones, transferred once.
+     * @param data The bytes.
+     * @returns The copy, and the buffer to transfer with the message holding it.
+     */
+    pack(data) {
+        if (data.byteLength >= exports.PACKED_SIZE)
+            return ownCopy(data);
+        let transfer;
+        if (!this.#chunk || this.#used + data.byteLength > CHUNK_SIZE) {
+            this.#chunk = new Uint8Array(CHUNK_SIZE);
+            this.#used = 0;
+            transfer = [this.#chunk.buffer];
+        }
+        const bytes = this.#chunk.subarray(this.#used, this.#used + data.byteLength);
+        bytes.set(data);
+        this.#used += data.byteLength;
+        return { bytes: bytes, transfer: transfer };
+    }
+    /**
+     * Add to the last message waiting when it is one of the same kind (the messages of a channel, the packets of a
+     * track, sent together: one message for many is much cheaper to send), else send a new one; the order holds.
+     * @param extend Adds to the last message waiting, when it may: whether it did.
+     * @param message The new message, else.
+     * @param transfer The buffers given to the other side.
+     */
+    postOrExtend(extend, message, transfer) {
+        if (this.#closed)
+            return;
+        const last = this.#queue.at(-1);
+        if (!last || !extend(last))
+            this.#queue.push(message());
+        if (transfer)
+            this.#transfer.push(...transfer);
+        this.#schedule();
+    }
+    /**
+     * Send a request, and wait for its reply.
+     * @param message The request.
+     * @param transfer The buffers given to the other side.
+     * @returns Its result.
+     * @throws {Error} The error of the other side, or the one the channel closed with.
+     */
+    request(message, transfer) {
+        if (this.#closed)
+            return Promise.reject(this.#closed);
+        const request = this.#next++;
+        return new Promise((resolve, reject) => {
+            this.#pending.set(request, { resolve: resolve, reject: reject });
+            this.post({ ...message, request: request }, transfer);
+        });
+    }
+    /**
+     * Call a function before each sending.
+     * @param callback The function: it posts what changed.
+     */
+    beforeSending(callback) {
+        this.#flushing.add(callback);
+    }
+    /**
+     * Send at the end of this turn of the event loop, even with no message waiting: what the callbacks given to
+     * beforeSending post.
+     */
+    schedule() {
+        if (!this.#closed)
+            this.#schedule();
+    }
+    /**
+     * Send what is waiting now, without waiting for the end of the turn of the event loop.
+     */
+    flush() {
+        this.#scheduled = false;
+        if (this.#closed)
+            return;
+        for (const callback of this.#flushing)
+            callback();
+        //The shared buffer goes with this sending
+        this.#chunk = undefined;
+        if (!this.#queue.length)
+            return;
+        const queue = this.#queue;
+        const transfer = this.#transfer;
+        this.#queue = [];
+        this.#transfer = [];
+        try {
+            this.#port.postMessage(queue, transfer);
+        }
+        catch (error) {
+            //A value that cannot be sent: the requests among the messages fail, the others are lost
+            log('a batch could not be sent: %O', error);
+            for (const item of queue)
+                if (item.request !== undefined)
+                    this.#reply(item.request, undefined, error);
+        }
+    }
+    /**
+     * Close the channel: the requests waiting and the next ones fail, nothing is sent any more.
+     * @param error Their error.
+     */
+    close(error) {
+        this.#closed ??= error;
+        this.#queue = [];
+        this.#transfer = [];
+        for (const { reject } of this.#pending.values())
+            reject(error);
+        this.#pending.clear();
+    }
+    /**
+     * Send at the end of the turn of the event loop
+     */
+    #schedule() {
+        if (this.#scheduled)
+            return;
+        this.#scheduled = true;
+        setImmediate(() => this.flush());
+    }
+    /**
+     * Read a message: a reply, a request, or a message not answered. A handler throwing does not stop the others
+     * @param item
+     */
+    #read(item) {
+        if (item.type === 'reply') {
+            const pending = this.#pending.get(item.reply);
+            this.#pending.delete(item.reply);
+            if (item.error === undefined)
+                pending?.resolve(item.result);
+            else
+                pending?.reject(threadErrorOf(item.error));
+            return;
+        }
+        const request = item.request;
+        let result;
+        try {
+            result = this.#handle(item);
+        }
+        catch (error) {
+            if (request === undefined)
+                log('a message failed: %O', error);
+            else
+                this.#reply(request, undefined, error);
+            return;
+        }
+        if (request === undefined) {
+            if (result instanceof Promise)
+                result.catch((error) => log('a message failed: %O', error));
+            return;
+        }
+        if (result instanceof Promise)
+            result.then((value) => this.#reply(request, value), (error) => this.#reply(request, undefined, error));
+        else
+            this.#reply(request, result);
+    }
+    /**
+     * Answer a request
+     * @param request
+     * @param result
+     * @param error
+     */
+    #reply(request, result, error) {
+        if (this.#closed)
+            return;
+        this.#queue.push(error === undefined ? { type: 'reply', reply: request, result: result } : { type: 'reply', reply: request, error: sentError(error) });
+        this.#schedule();
+    }
+}
+exports.PeerThreadChannel = PeerThreadChannel;

package/dist/cjs/peer/PeerThreadProtocol.d.ts

@@ -0,0 +1,325 @@
+import type { Extensions } from '../lib/rtp/index.js';
+import type { SignalingCandidate, SignalingDescription, SignalingIceServer } from '../protocol/SignalingProtocol.js';
+import type { DataChannelOptions } from '../shared/Connections.js';
+import type { EngineOptions } from './EngineConfig.js';
+import type { RtpTransceiverDirection } from './RtpTransceiver.js';
+/**
+ * What a worker thread of connections is started with
+ */
+export interface PeerWorkerData {
+    readonly thread: number;
+}
+/**
+ * A codec, as plain data
+ */
+export interface PeerCodec {
+    readonly payloadType?: number;
+    readonly mimeType: string;
+    readonly clockRate: number;
+    readonly channels?: number;
+    readonly parameters?: string;
+    readonly rtcpFeedback?: {
+        type: string;
+        parameter?: string;
+    }[];
+}
+/**
+ * A track received by a connection of a worker thread (its reference in the thread)
+ */
+export interface PeerTrackInfo {
+    readonly ref: string;
+    readonly kind: 'audio' | 'video';
+    readonly id: string;
+    readonly codec?: PeerCodec;
+}
+/**
+ * A transceiver of a connection of a worker thread (`m…` when added by the main thread, `w…` by the thread)
+ */
+export interface PeerTransceiverInfo {
+    readonly ref: string;
+    readonly kind: 'audio' | 'video';
+    readonly mid: string | null;
+    readonly direction: RtpTransceiverDirection;
+    readonly currentDirection: RtpTransceiverDirection | 'stopped' | null;
+    readonly reusable: boolean;
+    readonly sending: string | null;
+    readonly sendingCodec?: PeerCodec;
+    readonly receiving: PeerTrackInfo;
+}
+/**
+ * The state of a connection in a worker thread, sent with its events and the replies to its requests: the main thread
+ * reads its copy of it
+ */
+export interface PeerConnectionState {
+    readonly connectionState: 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed';
+    readonly iceConnectionState: string;
+    readonly iceGatheringState: string;
+    readonly signalingState: string;
+    readonly localDescription: SignalingDescription | null;
+    readonly remoteDescription: SignalingDescription | null;
+    readonly maxMessageSize: number | null;
+    readonly configuration: {
+        iceServers: SignalingIceServer[];
+        iceTransportPolicy: 'all' | 'relay';
+    };
+    readonly transceivers: PeerTransceiverInfo[];
+    readonly ops: number;
+    readonly seq: number;
+}
+/**
+ * What the main thread knows of a data channel of a worker thread
+ */
+export interface PeerChannelInfo {
+    readonly label: string;
+    readonly protocol: string;
+    readonly ordered: boolean;
+    readonly maxRetransmits: number | null;
+    readonly maxPacketLifeTime: number | null;
+    readonly negotiated: boolean;
+    readonly id: number | null;
+    readonly readyState: 'connecting' | 'open' | 'closing' | 'closed';
+}
+/**
+ * A method of a connection the main thread calls, and waits for
+ */
+export type PeerCall = {
+    method: 'createOffer';
+    args: [options: {
+        iceRestart?: boolean;
+    }];
+} | {
+    method: 'createAnswer';
+    args: [];
+} | {
+    method: 'setLocalDescription';
+    args: [description?: SignalingDescription];
+} | {
+    method: 'setRemoteDescription';
+    args: [description: SignalingDescription];
+} | {
+    method: 'addIceCandidate';
+    args: [candidate: SignalingCandidate];
+};
+/**
+ * A change of the transceivers by the main thread, numbered (`op`)
+ */
+export type PeerTransceiverChange = {
+    type: 'addTrack';
+    conn: number;
+    op: number;
+    track: string;
+    streams: string[];
+    transceiver: string | null;
+    created: string;
+} | {
+    type: 'addTransceiver';
+    conn: number;
+    op: number;
+    created: string;
+    kind: 'audio' | 'video';
+    track?: string;
+    direction: RtpTransceiverDirection;
+    streams: string[];
+} | {
+    type: 'removeTrack';
+    conn: number;
+    op: number;
+    transceiver: string;
+} | {
+    type: 'direction';
+    conn: number;
+    op: number;
+    transceiver: string;
+    direction: RtpTransceiverDirection;
+} | {
+    type: 'stopTransceiver';
+    conn: number;
+    op: number;
+    transceiver: string;
+} | {
+    type: 'replaceTrack';
+    conn: number;
+    op: number;
+    transceiver: string;
+    track: string | null;
+} | {
+    type: 'setStreams';
+    conn: number;
+    op: number;
+    transceiver: string;
+    streams: string[];
+};
+/**
+ * The messages of the main thread to a worker thread of connections (`conn` is the connection, `ch` a channel, `track`
+ * a track of the main thread sent, or a track received in the thread)
+ */
+export type PeerToWorker = {
+    type: 'open';
+    conn: number;
+    options: EngineOptions;
+} | {
+    type: 'call';
+    conn: number;
+} & PeerCall | {
+    type: 'close';
+    conn: number;
+} | {
+    type: 'restartIce';
+    conn: number;
+} | {
+    type: 'setConfiguration';
+    conn: number;
+    configuration: {
+        iceServers?: SignalingIceServer[];
+        iceTransportPolicy?: 'all' | 'relay';
+    };
+} | {
+    type: 'channel';
+    conn: number;
+    ch: string;
+    label: string;
+    options: DataChannelOptions;
+} | {
+    type: 'send';
+    conn: number;
+    ch: string;
+    data: (string | Uint8Array)[];
+} | {
+    type: 'closeChannel';
+    conn: number;
+    ch: string;
+} | {
+    type: 'mirror';
+    conn: number;
+    track: string;
+    kind: 'audio' | 'video';
+    id: string;
+    remote: boolean;
+    codec?: PeerCodec;
+} | {
+    type: 'rtp';
+    conn: number;
+    track: string;
+    packets: Uint8Array[];
+    extensions: (Extensions | null)[];
+} | {
+    type: 'source';
+    conn: number;
+    track: string;
+    header: {
+        sequenceNumber: number;
+        timestamp: number;
+    };
+} | {
+    type: 'mirrorEnded';
+    conn: number;
+    track: string;
+} | {
+    type: 'dropTrack';
+    conn: number;
+    track: string;
+} | PeerTransceiverChange | {
+    type: 'consumed';
+    conn: number;
+    bytes: number;
+    rtp: number;
+} | {
+    type: 'keyframe';
+    conn: number;
+    track: string;
+} | {
+    type: 'want';
+    conn: number;
+    track: string;
+    wanted: boolean;
+} | {
+    type: 'debug';
+    enabled: boolean;
+} | {
+    type: 'stop';
+};
+/**
+ * The messages of a worker thread of connections to the main thread
+ */
+export type PeerFromWorker = {
+    type: 'ready';
+} | {
+    type: 'event';
+    conn: number;
+    name: 'icecandidate';
+    candidate: SignalingCandidate | null;
+    state: PeerConnectionState;
+} | {
+    type: 'event';
+    conn: number;
+    name: 'negotiationneeded';
+    state: PeerConnectionState;
+} | {
+    type: 'event';
+    conn: number;
+    name: 'connectionstatechange' | 'iceconnectionstatechange' | 'icegatheringstatechange' | 'signalingstatechange';
+    value: string;
+    state: PeerConnectionState;
+} | {
+    type: 'state';
+    conn: number;
+    state: PeerConnectionState;
+} | {
+    type: 'datachannel';
+    conn: number;
+    ch: string;
+    info: PeerChannelInfo;
+} | {
+    type: 'channelState';
+    conn: number;
+    ch: string;
+    readyState: PeerChannelInfo['readyState'];
+    id: number | null;
+} | {
+    type: 'message';
+    conn: number;
+    ch: string;
+    data: (string | Uint8Array)[];
+} | {
+    type: 'buffered';
+    conn: number;
+    ch: string;
+    amount: number;
+    applied: number;
+} | {
+    type: 'channelError';
+    conn: number;
+    ch: string;
+    error: {
+        name: string;
+        message: string;
+    };
+} | {
+    type: 'track';
+    conn: number;
+    transceiver: PeerTransceiverInfo;
+    streams: string[];
+    state: PeerConnectionState;
+} | {
+    type: 'rtp';
+    conn: number;
+    track: string;
+    packets: Uint8Array[];
+    extensions: (Extensions | null)[];
+} | {
+    type: 'trackEnded';
+    conn: number;
+    track: string;
+} | {
+    type: 'consumed';
+    conn: number;
+    rtp: number;
+} | {
+    type: 'pli';
+    conn: number;
+    transceiver: string;
+} | {
+    type: 'log';
+    namespace: string;
+    message: string;
+};

package/dist/cjs/peer/PeerThreadProtocol.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });