@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/sfu/SFUWorker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What a worker thread forwarding rooms is started with
+ */
+export interface SFUWorkerData {
+    readonly thread: number;
+    readonly connection: Record<string, unknown>;
+    readonly select: boolean;
+}
+/**
+ * Forward the rooms the main thread opens in this worker thread: each is a SFURoom, whose signaling, hooks and events
+ * go through the parent port
+ */
+export declare function runSFUWorker(): void;

package/dist/cjs/sfu/SFUWorker.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSFUWorker = runSFUWorker;
+const node_util_1 = require("node:util");
+const node_worker_threads_1 = require("node:worker_threads");
+const core_1 = require("@lakutata/core");
+const log_js_1 = require("../lib/common/log.js");
+const MediaTrack_js_1 = require("../peer/MediaTrack.js");
+const PeerConnection_js_1 = require("../peer/PeerConnection.js");
+const SFURoom_js_1 = require("./SFURoom.js");
+const SFUWorkerChannel_js_1 = require("./SFUWorkerChannel.js");
+/**
+ * The key of several values
+ * @param parts
+ */
+function keyOf(...parts) {
+    return parts.join('\n');
+}
+/**
+ * Forward the rooms the main thread opens in this worker thread: each is a SFURoom, whose signaling, hooks and events
+ * go through the parent port
+ */
+function runSFUWorker() {
+    if (!node_worker_threads_1.parentPort)
+        throw new Error('The media server forwards in a worker thread only');
+    const data = node_worker_threads_1.workerData;
+    const container = new core_1.Container();
+    const rooms = new Map();
+    //The receivers of the members of the rooms (by room and member), the legs of WHIP and WHEP, the tracks read by the
+    //main thread (by room, member and track)
+    const receivers = new Map();
+    const legs = new Map();
+    const streams = new Map();
+    const channel = new SFUWorkerChannel_js_1.SFUWorkerChannel(node_worker_threads_1.parentPort, (message) => handle(message));
+    const roomOf = (ref) => {
+        const room = rooms.get(ref);
+        if (!room)
+            throw new Error('The room is not served any more');
+        return room;
+    };
+    //A leg of WHIP or WHEP: its end is told to the main thread
+    const keep = (id, leg) => {
+        legs.set(id, leg);
+        leg.ended(() => {
+            if (legs.get(id) === leg)
+                legs.delete(id);
+            channel.post({ type: 'ended', leg: id });
+        });
+    };
+    //The packets of a track sent to the main thread, while they are wanted there
+    const stream = (ref, peerId, trackId, wanted) => {
+        const key = keyOf(ref, peerId, trackId);
+        streams.get(key)?.();
+        streams.delete(key);
+        const media = wanted ? rooms.get(ref)?.track(peerId, trackId) : undefined;
+        if (!media)
+            return;
+        streams.set(key, (0, MediaTrack_js_1.engineTrackOf)(media).onReceiveRtp.subscribe((packet, extensions) => {
+            //Its own buffer, given to the main thread
+            const bytes = new Uint8Array(packet.serialize());
+            channel.post({ type: 'rtp', ref: ref, peerId: peerId, trackId: trackId, packet: bytes, extensions: extensions }, [bytes.buffer]);
+        }).unSubscribe);
+    };
+    const hostOf = (ref, id) => ({
+        id: id,
+        signaling: {
+            join: async (peerId, _room, options) => {
+                receivers.set(keyOf(ref, peerId), options.receive);
+                try {
+                    return await channel.request({ type: 'join', ref: ref, peerId: peerId, role: options.role });
+                }
+                catch (error) {
+                    receivers.delete(keyOf(ref, peerId));
+                    throw error;
+                }
+            },
+            leave: async (peerId) => {
+                receivers.delete(keyOf(ref, peerId));
+                await channel.request({ type: 'leave', ref: ref, peerId: peerId });
+            },
+            signal: (peerId, _room, to, signal) => channel.request({ type: 'signal', ref: ref, peerId: peerId, to: to, signal: signal })
+        },
+        connect: () => container.get(PeerConnection_js_1.PeerConnection, data.connection),
+        select: data.select
+            ? (subscriber, track) => channel.request({ type: 'select', subscriber: subscriber, track: track })
+            : () => true,
+        emit: (event, ...args) => {
+            const track = event === 'publish' || event === 'unpublish' ? args[0] : undefined;
+            //The id and the codec of a track published, for the track read in the main thread
+            let published;
+            const media = event === 'publish' && track ? rooms.get(ref)?.track(track.peerId, track.id) : undefined;
+            if (media) {
+                const codec = (0, MediaTrack_js_1.engineTrackOf)(media).codec;
+                published = { id: media.id, ...codec ? { codec: { payloadType: codec.payloadType, mimeType: codec.mimeType, clockRate: codec.clockRate, channels: codec.channels, parameters: codec.parameters } } : {} };
+            }
+            if (event === 'unpublish' && track)
+                stream(ref, track.peerId, track.id, false);
+            channel.post({ type: 'emit', ref: ref, event: event, args: args, ...published ? { media: published } : {} });
+        },
+        emptied: () => channel.post({ type: 'emptied', ref: ref }),
+        changed: (room) => channel.post({ type: 'state', ref: ref, members: room.members, viewers: room.viewers }),
+        sourced: (viewerId, source) => channel.post({ type: 'source', leg: viewerId, source: source }),
+        known: (_room, tracks) => channel.post({ type: 'known', ref: ref, tracks: tracks })
+    });
+    const handle = async (message) => {
+        switch (message.type) {
+            case 'open': {
+                const room = new SFURoom_js_1.SFURoom(hostOf(message.ref, message.id), message.room);
+                rooms.set(message.ref, room);
+                try {
+                    await room.ready;
+                }
+                catch (error) {
+                    if (rooms.get(message.ref) === room)
+                        rooms.delete(message.ref);
+                    throw error;
+                }
+                return undefined;
+            }
+            case 'close': {
+                const room = rooms.get(message.ref);
+                rooms.delete(message.ref);
+                await room?.close();
+                return undefined;
+            }
+            case 'publish': {
+                const leg = await roomOf(message.ref).publish(message.peerId, message.offer);
+                keep(message.peerId, leg);
+                return { answer: leg.answer };
+            }
+            case 'play': {
+                const viewerId = message.viewerId;
+                const leg = await roomOf(message.ref).play(viewerId, message.offer, message.select
+                    ? (tracks) => channel.request({ type: 'choose', leg: viewerId, tracks: tracks })
+                    : undefined);
+                keep(viewerId, leg);
+                return { answer: leg.answer, source: leg.source() };
+            }
+            case 'patch': {
+                const leg = legs.get(message.leg);
+                if (!leg)
+                    throw new Error('There is no such session');
+                return await leg.patch(message.fragment, message.restart);
+            }
+            case 'end':
+                return legs.get(message.leg)?.close();
+            case 'receive':
+                return receivers.get(keyOf(message.ref, message.peerId))?.(message.event, message.payload);
+            case 'stream':
+                return stream(message.ref, message.peerId, message.trackId, message.wanted);
+            case 'keyframe':
+                return rooms.get(message.ref)?.track(message.peerId, message.trackId)?.requestKeyFrame();
+            case 'debug':
+                //The debug messages go to the handler of the main thread while it has one
+                return (0, log_js_1.setDebugHandler)(message.enabled
+                    ? (namespace, args) => channel.post({ type: 'log', namespace: namespace, message: `[thread ${data.thread}] ${(0, node_util_1.format)(...args)}` })
+                    : undefined);
+            case 'stop': {
+                const closing = [...rooms.values()];
+                rooms.clear();
+                await Promise.all(closing.map((room) => room.close()));
+                await container.destroy();
+                return undefined;
+            }
+        }
+    };
+    channel.post({ type: 'ready' });
+}

package/dist/cjs/sfu/SFUWorkerChannel.d.ts

@@ -0,0 +1,204 @@
+import type { Transferable } from 'node:worker_threads';
+import type { SignalingDescription, SignalingPeer, SignalingRole, SignalingStream, SignalingCandidate } from '../protocol/SignalingProtocol.js';
+import type { SFUTrack } from './SFU.js';
+import type { SFUOfferedTrack } from './SFURoom.js';
+/**
+ * The codec of a track published, as the worker thread gives it (the fields of the codec parameters of the engine)
+ */
+export interface SFUWorkerCodec {
+    readonly payloadType?: number;
+    readonly mimeType: string;
+    readonly clockRate: number;
+    readonly channels?: number;
+    readonly parameters?: string;
+}
+/**
+ * The track of the engine of a track published: its id and its codec
+ */
+export interface SFUWorkerMedia {
+    readonly id: string;
+    readonly codec?: SFUWorkerCodec;
+}
+/**
+ * The messages of the main thread to a worker thread forwarding rooms. `ref` is the number of a room in the pool (the
+ * same name may be served again by another), `leg` the id of a member published with WHIP or of a viewer of WHEP.
+ */
+export type SFUToWorker = {
+    type: 'open';
+    request: number;
+    ref: number;
+    room: string;
+    id: string;
+} | {
+    type: 'close';
+    request: number;
+    ref: number;
+} | {
+    type: 'publish';
+    request: number;
+    ref: number;
+    peerId: string;
+    offer: SignalingDescription;
+} | {
+    type: 'play';
+    request: number;
+    ref: number;
+    viewerId: string;
+    offer: SignalingDescription;
+    select: boolean;
+} | {
+    type: 'patch';
+    request: number;
+    leg: string;
+    fragment: string;
+    restart: boolean;
+} | {
+    type: 'end';
+    leg: string;
+} | {
+    type: 'receive';
+    ref: number;
+    peerId: string;
+    event: string;
+    payload: unknown;
+} | {
+    type: 'stream';
+    ref: number;
+    peerId: string;
+    trackId: string;
+    wanted: boolean;
+} | {
+    type: 'keyframe';
+    ref: number;
+    peerId: string;
+    trackId: string;
+} | {
+    type: 'stop';
+    request: number;
+} | {
+    type: 'debug';
+    enabled: boolean;
+};
+/**
+ * The messages of a worker thread to the main thread
+ */
+export type SFUFromWorker = {
+    type: 'ready';
+} | {
+    type: 'join';
+    request: number;
+    ref: number;
+    peerId: string;
+    role: SignalingRole;
+} | {
+    type: 'leave';
+    request: number;
+    ref: number;
+    peerId: string;
+} | {
+    type: 'signal';
+    request: number;
+    ref: number;
+    peerId: string;
+    to: string;
+    signal: {
+        description?: SignalingDescription;
+        candidate?: SignalingCandidate | null;
+        streams?: SignalingStream[];
+    };
+} | {
+    type: 'select';
+    request: number;
+    subscriber: SignalingPeer;
+    track: SFUTrack;
+} | {
+    type: 'choose';
+    request: number;
+    leg: string;
+    tracks: SFUTrack[];
+} | {
+    type: 'emit';
+    ref: number;
+    event: string;
+    args: unknown[];
+    media?: SFUWorkerMedia;
+} | {
+    type: 'state';
+    ref: number;
+    members: string[];
+    viewers: number;
+} | {
+    type: 'source';
+    leg: string;
+    source: string | undefined;
+} | {
+    type: 'ended';
+    leg: string;
+} | {
+    type: 'emptied';
+    ref: number;
+} | {
+    type: 'rtp';
+    ref: number;
+    peerId: string;
+    trackId: string;
+    packet: Uint8Array;
+    extensions?: Record<string, unknown>;
+} | {
+    type: 'log';
+    namespace: string;
+    message: string;
+} | {
+    type: 'known';
+    ref: number;
+    tracks: SFUOfferedTrack[];
+};
+/**
+ * Where the messages go and come from: the parent port in a worker thread, the worker in the main thread
+ */
+export interface SFUWorkerPort {
+    postMessage(message: unknown, transfer?: readonly Transferable[]): void;
+    on(event: 'message', listener: (message: unknown) => void): unknown;
+}
+/**
+ * The messages of a request, without their number (given by the channel)
+ */
+type Unnumbered<Message> = Message extends {
+    request: number;
+} ? Omit<Message, 'request'> : never;
+/**
+ * The messages of a side to the other: the requests are answered (their result, or the message of their error), the
+ * others are not
+ */
+export declare class SFUWorkerChannel<Incoming extends {
+    type: string;
+}, Outgoing 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: SFUWorkerPort, handle: (message: Incoming) => unknown);
+    /**
+     * Send a request, and wait for its reply.
+     * @param message The request.
+     * @returns Its result.
+     * @throws {Error} The error of the other side, or the one the channel closed with.
+     */
+    request<Result>(message: Unnumbered<Outgoing>): Promise<Result>;
+    /**
+     * Send a message that is not answered.
+     * @param message The message.
+     * @param transfer The buffers given to the other side.
+     */
+    post(message: Outgoing, transfer?: readonly Transferable[]): void;
+    /**
+     * Close the channel: the requests waiting and the next ones fail.
+     * @param error Their error.
+     */
+    close(error: Error): void;
+}
+export {};

package/dist/cjs/sfu/SFUWorkerChannel.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFUWorkerChannel = void 0;
+/**
+ * The messages of a side to the other: the requests are answered (their result, or the message of their error), the
+ * others are not
+ */
+class SFUWorkerChannel {
+    #port;
+    #pending = new Map();
+    #next = 1;
+    #closed;
+    /**
+     * 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;
+        port.on('message', (message) => {
+            const received = message;
+            if (received.type === 'reply') {
+                const { reply, result, error } = received;
+                const pending = this.#pending.get(reply);
+                this.#pending.delete(reply);
+                if (error === undefined)
+                    pending?.resolve(result);
+                else
+                    pending?.reject(new Error(error));
+                return;
+            }
+            const request = received.request;
+            if (request === undefined) {
+                //A message that is not a request has no reply
+                try {
+                    const result = handle(received);
+                    if (result instanceof Promise)
+                        result.catch(() => undefined);
+                }
+                catch {
+                    //Nothing to answer
+                }
+                return;
+            }
+            Promise.resolve().then(() => handle(received)).then((result) => this.#reply({ type: 'reply', reply: request, result: result }), (error) => this.#reply({ type: 'reply', reply: request, error: error instanceof Error ? error.message : String(error) }));
+        });
+    }
+    /**
+     * Send a request, and wait for its reply.
+     * @param message The request.
+     * @returns Its result.
+     * @throws {Error} The error of the other side, or the one the channel closed with.
+     */
+    request(message) {
+        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 });
+            try {
+                this.#port.postMessage({ ...message, request: request });
+            }
+            catch (error) {
+                //A request that cannot be sent
+                this.#pending.delete(request);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Send a message that is not answered.
+     * @param message The message.
+     * @param transfer The buffers given to the other side.
+     */
+    post(message, transfer) {
+        if (!this.#closed)
+            this.#port.postMessage(message, transfer);
+    }
+    /**
+     * Close the channel: the requests waiting and the next ones fail.
+     * @param error Their error.
+     */
+    close(error) {
+        this.#closed ??= error;
+        for (const { reject } of this.#pending.values())
+            reject(error);
+        this.#pending.clear();
+    }
+    /**
+     * Send a reply
+     * @param reply
+     */
+    #reply(reply) {
+        if (this.#closed)
+            return;
+        try {
+            this.#port.postMessage(reply);
+        }
+        catch (error) {
+            //A result that cannot be sent
+            this.#port.postMessage({ type: 'reply', reply: reply.reply, error: error.message });
+        }
+    }
+}
+exports.SFUWorkerChannel = SFUWorkerChannel;

package/dist/cjs/sfu/SFUWorkerCode.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The code of the worker threads of the media server: SFUWorker and the engine bundled into one script, written by the
+ * build (scripts/workers.mjs) in place of this empty one
+ */
+export declare const sfuWorkerCode: string;