@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/peer/PeerWorker.js

@@ -0,0 +1,458 @@
+import { format } from 'node:util';
+import { parentPort, workerData } from 'node:worker_threads';
+import { getDataChannelMessageSize } from '../lib/peer/dataChannel.js';
+import { RTCRtpCodecParameters } from '../lib/peer/media/parameters.js';
+import { MediaStream, MediaStreamTrack } from '../lib/peer/media/track.js';
+import { RTCPeerConnection } from '../lib/peer/peerConnection.js';
+import { RtpPacket } from '../lib/rtp/index.js';
+import { engineConfigOf } from './EngineConfig.js';
+import { debug, setDebugHandler } from '../lib/common/log.js';
+import { PeerThreadChannel, RTP_IN_FLIGHT, sentError } from './PeerThreadChannel.js';
+/**
+ * A plain description
+ * @param description
+ */
+function plainDescription(description) {
+    return description ? { type: description.type, sdp: description.sdp } : null;
+}
+/**
+ * A codec as plain data
+ * @param codec
+ */
+function plainCodec(codec) {
+    return {
+        payloadType: codec.payloadType,
+        mimeType: codec.mimeType,
+        clockRate: codec.clockRate,
+        channels: codec.channels,
+        parameters: codec.parameters,
+        rtcpFeedback: codec.rtcpFeedback.map((feedback) => ({ type: feedback.type, parameter: feedback.parameter }))
+    };
+}
+/**
+ * What the main thread knows of a channel
+ * @param engine
+ */
+function infoOf(engine) {
+    return {
+        label: engine.label,
+        protocol: engine.protocol,
+        ordered: engine.ordered,
+        maxRetransmits: engine.maxRetransmits,
+        maxPacketLifeTime: engine.maxPacketLifeTime,
+        negotiated: engine.negotiated,
+        id: engine.id ?? null,
+        readyState: engine.readyState
+    };
+}
+const log = debug('webrtc/peer/threads');
+/**
+ * Serve the connections the main thread opens in this worker thread (the `threads` option of a connection): their
+ * engines run here, their methods are called from the main thread, their events, their state, the messages of their
+ * channels and the packets of the tracks received go to it, the packets of the tracks sent come from it
+ */
+export function runPeerWorker() {
+    if (!parentPort)
+        throw new Error('The connections of a thread are served in a worker thread only');
+    const data = workerData;
+    const connections = new Map();
+    const channel = new PeerThreadChannel(parentPort, (message) => handle(message));
+    //The amounts buffered that changed, one report per channel and turn of the event loop
+    channel.beforeSending(() => {
+        for (const served of connections.values()) {
+            for (const changed of served.changed)
+                channel.post({ type: 'buffered', conn: served.conn, ch: changed.ref, amount: changed.engine.bufferedAmount, applied: changed.applied });
+            served.changed.clear();
+        }
+    });
+    const servedOf = (conn) => {
+        const served = connections.get(conn);
+        if (!served)
+            throw Object.assign(new Error('The connection is closed'), { name: 'InvalidStateError' });
+        return served;
+    };
+    //A track received, known to the main thread by its reference; its end is told there
+    const receivedRef = (served, track, receiver) => {
+        let ref = served.receivedRefs.get(track);
+        if (ref)
+            return ref;
+        ref = `r${served.next++}`;
+        served.receivedRefs.set(track, ref);
+        served.received.set(ref, { track: track, receiver: receiver });
+        const known = ref;
+        track.once('ended', () => {
+            served.received.get(known)?.unsubscribe?.();
+            served.received.delete(known);
+            channel.post({ type: 'trackEnded', conn: served.conn, track: known });
+        });
+        return ref;
+    };
+    //A transceiver, known to the main thread by its reference: the key frame requests of its sender are told there
+    const transceiverRef = (served, transceiver, given) => {
+        let ref = served.transceiverRefs.get(transceiver);
+        if (ref)
+            return ref;
+        ref = given ?? `w${served.next++}`;
+        served.transceiverRefs.set(transceiver, ref);
+        served.transceivers.set(ref, transceiver);
+        const known = ref;
+        transceiver.sender.onPictureLossIndication.subscribe(() => channel.post({ type: 'pli', conn: served.conn, transceiver: known }));
+        return ref;
+    };
+    const transceiverInfo = (served, transceiver) => {
+        const received = transceiver.receiver.track;
+        const receiving = {
+            ref: receivedRef(served, received, transceiver.receiver),
+            kind: received.kind,
+            id: received.id ?? received.uuid,
+            ...received.codec ? { codec: plainCodec(received.codec) } : {}
+        };
+        const sent = transceiver.sender.track;
+        return {
+            ref: transceiverRef(served, transceiver),
+            kind: transceiver.kind,
+            mid: transceiver.mid,
+            direction: transceiver.direction,
+            currentDirection: transceiver.currentDirection,
+            reusable: served.engine.reusableForTrack(transceiver),
+            sending: sent ? served.mirrorRefs.get(sent) ?? null : null,
+            ...sent?.codec ? { sendingCodec: plainCodec(sent.codec) } : {},
+            receiving: receiving
+        };
+    };
+    //The state of a connection, as the main thread reads it
+    const stateOf = (served) => {
+        const engine = served.engine;
+        const sctp = engine.sctpTransport;
+        const configuration = engine.getConfiguration();
+        return {
+            connectionState: engine.connectionState,
+            iceConnectionState: engine.iceConnectionState,
+            iceGatheringState: engine.iceGatheringState,
+            signalingState: engine.signalingState,
+            localDescription: plainDescription(engine.localDescription),
+            remoteDescription: plainDescription(engine.remoteDescription),
+            maxMessageSize: sctp ? sctp.remoteMaxMessageSize : null,
+            configuration: { iceServers: configuration.iceServers, iceTransportPolicy: configuration.iceTransportPolicy },
+            transceivers: engine.getTransceivers().map((transceiver) => transceiverInfo(served, transceiver)),
+            ops: served.ops,
+            seq: ++served.seq
+        };
+    };
+    //A channel of a connection, its events sent to the main thread
+    const adopt = (served, engine, ref) => {
+        const adopted = { ref: ref, engine: engine, applied: 0 };
+        served.channels.set(ref, adopted);
+        engine.stateChanged.subscribe((readyState) => {
+            channel.post({ type: 'channelState', conn: served.conn, ch: ref, readyState: readyState, id: engine.id ?? null });
+            if (readyState === 'closed')
+                served.channels.delete(ref);
+        });
+        engine.onMessage.subscribe((message) => {
+            //Out of the receive window until the main thread reads it: a main thread reading slowly slows the sender
+            served.engine.sctpTransport?.holdReceived(getDataChannelMessageSize(message));
+            //A copy: the buffer of the engine may hold other values (a buffer of the pool of Node.js, a datagram)
+            const { bytes, transfer } = typeof message === 'string' ? { bytes: message, transfer: undefined } : channel.pack(message);
+            //With the messages of the channel received just before
+            channel.postOrExtend((last) => last.type === 'message' && last.conn === served.conn && last.ch === ref && last.data.push(bytes) > 0, () => ({ type: 'message', conn: served.conn, ch: ref, data: [bytes] }), transfer);
+        });
+        engine.bufferedAmountChanged.subscribe(() => {
+            served.changed.add(adopted);
+            channel.schedule();
+        });
+        engine.error.subscribe((error) => channel.post({ type: 'channelError', conn: served.conn, ch: ref, error: sentError(error) }));
+        return adopted;
+    };
+    const open = (conn, engine) => {
+        const served = {
+            conn: conn,
+            engine: engine,
+            channels: new Map(),
+            changed: new Set(),
+            transceivers: new Map(),
+            transceiverRefs: new WeakMap(),
+            mirrors: new Map(),
+            mirrorRefs: new WeakMap(),
+            received: new Map(),
+            receivedRefs: new WeakMap(),
+            next: 1,
+            ops: 0,
+            seq: 0,
+            rtpOut: 0,
+            rtpRead: 0
+        };
+        connections.set(conn, served);
+        engine.onIceCandidate.subscribe((candidate) => {
+            const plain = candidate
+                ? { candidate: candidate.candidate, sdpMid: candidate.sdpMid ?? null, sdpMLineIndex: candidate.sdpMLineIndex ?? null, usernameFragment: candidate.usernameFragment ?? null }
+                : null;
+            channel.post({ type: 'event', conn: conn, name: 'icecandidate', candidate: plain, state: stateOf(served) });
+        });
+        engine.onDataChannel.subscribe((created) => {
+            const ref = `w${served.next++}`;
+            adopt(served, created, ref);
+            channel.post({ type: 'datachannel', conn: conn, ch: ref, info: infoOf(created) });
+        });
+        engine.on('track', (event) => {
+            channel.post({
+                type: 'track',
+                conn: conn,
+                transceiver: transceiverInfo(served, event.transceiver),
+                streams: event.streams.map((stream) => stream.id),
+                state: stateOf(served)
+            });
+        });
+        engine.onNegotiationneeded.subscribe(() => channel.post({ type: 'event', conn: conn, name: 'negotiationneeded', state: stateOf(served) }));
+        engine.connectionStateChange.subscribe((value) => channel.post({ type: 'event', conn: conn, name: 'connectionstatechange', value: value, state: stateOf(served) }));
+        engine.iceConnectionStateChange.subscribe((value) => channel.post({ type: 'event', conn: conn, name: 'iceconnectionstatechange', value: value, state: stateOf(served) }));
+        engine.iceGatheringStateChange.subscribe((value) => channel.post({ type: 'event', conn: conn, name: 'icegatheringstatechange', value: value, state: stateOf(served) }));
+        engine.signalingStateChange.subscribe((value) => channel.post({ type: 'event', conn: conn, name: 'signalingstatechange', value: value, state: stateOf(served) }));
+        return served;
+    };
+    const mirrorOf = (served, ref) => {
+        const mirror = served.mirrors.get(ref);
+        if (!mirror)
+            throw new Error(`The track ${ref} is not known`);
+        return mirror;
+    };
+    const transceiverOf = (served, ref) => {
+        const transceiver = served.transceivers.get(ref);
+        if (!transceiver)
+            throw new Error(`The transceiver ${ref} is not known`);
+        return transceiver;
+    };
+    //A change of the transceivers by the main thread, then the state it makes, with its number
+    const change = async (served, message) => {
+        const streams = (ids) => ids.map((id) => new MediaStream({ id: id }));
+        try {
+            switch (message.type) {
+                case 'addTrack': {
+                    const chosen = message.transceiver === null ? null : served.transceivers.get(message.transceiver) ?? null;
+                    const sender = served.engine.addTrackOn(chosen, mirrorOf(served, message.track), ...streams(message.streams));
+                    const added = served.engine.getTransceivers().find((transceiver) => transceiver.sender === sender);
+                    if (added)
+                        transceiverRef(served, added, message.created);
+                    break;
+                }
+                case 'addTransceiver': {
+                    const added = served.engine.addTransceiver(message.track === undefined ? message.kind : mirrorOf(served, message.track), {
+                        direction: message.direction,
+                        streams: streams(message.streams)
+                    });
+                    transceiverRef(served, added, message.created);
+                    break;
+                }
+                case 'removeTrack':
+                    served.engine.removeTrack(transceiverOf(served, message.transceiver).sender);
+                    break;
+                case 'direction':
+                    transceiverOf(served, message.transceiver).direction = message.direction;
+                    break;
+                case 'stopTransceiver':
+                    transceiverOf(served, message.transceiver).stop();
+                    break;
+                case 'replaceTrack':
+                    await transceiverOf(served, message.transceiver).sender.replaceTrack(message.track === null ? null : mirrorOf(served, message.track));
+                    break;
+                case 'setStreams':
+                    transceiverOf(served, message.transceiver).sender.setStreams(streams(message.streams));
+                    break;
+            }
+        }
+        finally {
+            served.ops = Math.max(served.ops, message.op);
+            channel.post({ type: 'state', conn: served.conn, state: stateOf(served) });
+        }
+    };
+    const handle = async (message) => {
+        switch (message.type) {
+            case 'open': {
+                const served = open(message.conn, new RTCPeerConnection(engineConfigOf(message.options)));
+                return stateOf(served);
+            }
+            case 'call': {
+                const served = servedOf(message.conn);
+                const engine = served.engine;
+                let result;
+                switch (message.method) {
+                    case 'createOffer':
+                        result = plainDescription(await engine.createOffer(message.args[0]));
+                        break;
+                    case 'createAnswer':
+                        result = plainDescription(await engine.createAnswer());
+                        break;
+                    case 'setLocalDescription':
+                        await engine.setLocalDescription(message.args[0]);
+                        break;
+                    case 'setRemoteDescription':
+                        await engine.setRemoteDescription(message.args[0]);
+                        break;
+                    case 'addIceCandidate': {
+                        const candidate = message.args[0];
+                        await engine.addIceCandidate({
+                            candidate: candidate.candidate,
+                            sdpMid: candidate.sdpMid ?? undefined,
+                            sdpMLineIndex: candidate.sdpMLineIndex ?? undefined,
+                            usernameFragment: candidate.usernameFragment ?? undefined
+                        });
+                        break;
+                    }
+                }
+                return { result: result, state: stateOf(served) };
+            }
+            case 'close': {
+                const served = connections.get(message.conn);
+                if (!served)
+                    return undefined;
+                await served.engine.close();
+                for (const mirror of served.mirrors.values())
+                    mirror.stop();
+                //The last events of the connection are sent before the reply
+                connections.delete(message.conn);
+                return stateOf(served);
+            }
+            case 'restartIce':
+                return servedOf(message.conn).engine.restartIce();
+            case 'setConfiguration':
+                return servedOf(message.conn).engine.setConfiguration(message.configuration);
+            case 'channel': {
+                const served = servedOf(message.conn);
+                let created;
+                try {
+                    created = served.engine.createDataChannel(message.label, message.options);
+                }
+                catch (error) {
+                    //Created in the main thread already: it fails there, and closes
+                    channel.post({ type: 'channelError', conn: message.conn, ch: message.ch, error: sentError(error) });
+                    channel.post({ type: 'channelState', conn: message.conn, ch: message.ch, readyState: 'closed', id: null });
+                    return undefined;
+                }
+                adopt(served, created, message.ch);
+                //Its id, known once created
+                channel.post({ type: 'channelState', conn: message.conn, ch: message.ch, readyState: created.readyState, id: created.id ?? null });
+                return undefined;
+            }
+            case 'send': {
+                const served = connections.get(message.conn);
+                const target = served?.channels.get(message.ch);
+                if (!served || !target)
+                    return undefined;
+                served.changed.add(target);
+                for (const data of message.data) {
+                    const payload = typeof data === 'string' ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+                    target.applied += getDataChannelMessageSize(payload);
+                    try {
+                        target.engine.send(payload);
+                    }
+                    catch (error) {
+                        //Closed meanwhile, or too large for the other peer: the error of the channel
+                        channel.post({ type: 'channelError', conn: message.conn, ch: message.ch, error: sentError(error) });
+                    }
+                }
+                return undefined;
+            }
+            case 'closeChannel':
+                return connections.get(message.conn)?.channels.get(message.ch)?.engine.close();
+            case 'mirror': {
+                const served = servedOf(message.conn);
+                const mirror = new MediaStreamTrack({
+                    kind: message.kind,
+                    id: message.id,
+                    remote: message.remote,
+                    ...message.codec ? { codec: new RTCRtpCodecParameters(message.codec) } : {}
+                });
+                served.mirrors.set(message.track, mirror);
+                served.mirrorRefs.set(mirror, message.track);
+                return undefined;
+            }
+            case 'rtp': {
+                const served = connections.get(message.conn);
+                if (!served)
+                    return undefined;
+                const mirror = served.mirrors.get(message.track);
+                //What was read, told at the end of the turn of the event loop
+                if (!served.rtpRead) {
+                    setImmediate(() => {
+                        channel.post({ type: 'consumed', conn: served.conn, rtp: served.rtpRead });
+                        served.rtpRead = 0;
+                    });
+                }
+                for (const bytes of message.packets)
+                    served.rtpRead += bytes.byteLength;
+                message.packets.forEach((bytes, index) => {
+                    mirror?.applyIncomingRtp(RtpPacket.deSerialize(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)), message.extensions[index] ?? undefined);
+                });
+                return undefined;
+            }
+            case 'consumed': {
+                const served = connections.get(message.conn);
+                if (!served)
+                    return undefined;
+                served.rtpOut -= message.rtp;
+                if (message.bytes)
+                    served.engine.sctpTransport?.releaseReceived(message.bytes);
+                return undefined;
+            }
+            case 'source':
+                return connections.get(message.conn)?.mirrors.get(message.track)?.onSourceChanged.execute(message.header);
+            case 'mirrorEnded':
+                return connections.get(message.conn)?.mirrors.get(message.track)?.stop();
+            case 'dropTrack': {
+                const served = connections.get(message.conn);
+                served?.mirrors.get(message.track)?.stop();
+                served?.mirrors.delete(message.track);
+                return undefined;
+            }
+            case 'addTrack':
+            case 'addTransceiver':
+            case 'removeTrack':
+            case 'direction':
+            case 'stopTransceiver':
+            case 'replaceTrack':
+            case 'setStreams':
+                //replaceTrack is a request: it resolves once the sender sends the new track
+                return await change(servedOf(message.conn), message);
+            case 'keyframe': {
+                const received = connections.get(message.conn)?.received.get(message.track);
+                const ssrc = received?.track.ssrc;
+                if (received && ssrc !== undefined)
+                    void received.receiver.sendRtcpPLI(ssrc);
+                return undefined;
+            }
+            case 'want': {
+                const served = connections.get(message.conn);
+                const received = served?.received.get(message.track);
+                if (!served || !received)
+                    return undefined;
+                received.unsubscribe?.();
+                received.unsubscribe = undefined;
+                if (message.wanted) {
+                    const ref = message.track;
+                    received.unsubscribe = received.track.onReceiveRtp.subscribe((packet, extensions) => {
+                        const serialized = packet.serialize();
+                        //The main thread reads too slowly: dropped, as by a full UDP buffer
+                        if (served.rtpOut + serialized.length > RTP_IN_FLIGHT)
+                            return log('a packet of the track %s dropped: the main thread reads too slowly', ref);
+                        served.rtpOut += serialized.length;
+                        const { bytes, transfer } = channel.pack(serialized);
+                        //With the packets of the track received just before
+                        channel.postOrExtend((last) => last.type === 'rtp' && last.conn === served.conn && last.track === ref && last.packets.push(bytes) > 0 && last.extensions.push(extensions ?? null) > 0, () => ({ type: 'rtp', conn: served.conn, track: ref, packets: [bytes], extensions: [extensions ?? null] }), transfer);
+                    }).unSubscribe;
+                }
+                return undefined;
+            }
+            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 = [...connections.values()];
+                connections.clear();
+                await Promise.all(closing.map((served) => served.engine.close()));
+                return undefined;
+            }
+        }
+    };
+    channel.post({ type: 'ready' });
+}