@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/esm/sfu/SFUWorker.js

@@ -0,0 +1,165 @@
+import { format } from 'node:util';
+import { parentPort, workerData } from 'node:worker_threads';
+import { Container } from '@lakutata/core';
+import { setDebugHandler } from '../lib/common/log.js';
+import { engineTrackOf } from '../peer/MediaTrack.js';
+import { PeerConnection } from '../peer/PeerConnection.js';
+import { SFURoom } from './SFURoom.js';
+import { SFUWorkerChannel } from './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
+ */
+export function runSFUWorker() {
+    if (!parentPort)
+        throw new Error('The media server forwards in a worker thread only');
+    const data = workerData;
+    const container = new 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(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, 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, 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 = 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(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 setDebugHandler(message.enabled
+                    ? (namespace, args) => channel.post({ type: 'log', namespace: namespace, message: `[thread ${data.thread}] ${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/esm/sfu/SFUWorkerChannel.js

@@ -0,0 +1,101 @@
+/**
+ * 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 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 });
+        }
+    }
+}