@4players/odin-plugin-web 1.0.0-alpha.2 → 1.0.0-alpha.20

package/lib/plugin/webrtc/mainConnection.js

@@ -0,0 +1,455 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, } from '@4players/odin-common';
+import { ConnectionStatus, } from '../mainConnection';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+import { connect } from './websocket';
+import { HealthCheckTimeout, logger, MainConnectionPingInterval, WebRtcIceTimeout, WebRtcTimeout, } from '../config';
+import { Transport } from '../index';
+export class WebRtcMainConnection {
+    static create(id, address, onDatagram, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (signal.aborted)
+                return failure('aborted');
+            let url;
+            try {
+                url = new URL(`wss://${address}`);
+            }
+            catch (error) {
+                return fail(`address in token(${address}) can not be parsed; ${error}`);
+            }
+            const webSocketUrl = extendUrl(url, 'main');
+            if (webSocketUrl.type !== 'Success')
+                return webSocketUrl;
+            const webSocket = yield connect(webSocketUrl.value, signal);
+            if (webSocket.type !== 'Success')
+                return webSocket;
+            const connection = new TypedRpcConnection(new RpcConnection(webSocket.value), MainCommandsRpc, MainNotificationsRpc);
+            try {
+                return success(new WebRtcMainConnection(id, address, url, onDatagram, connection, new RTCPeerConnection()));
+            }
+            catch (reason) {
+                connection.close();
+                return failure(`unable to create webrtc connection; ${reason}`);
+            }
+        });
+    }
+    get transport() {
+        return Transport.H3;
+    }
+    get closePromise() {
+        return this._ClosePromise;
+    }
+    get closeSignal() {
+        return this.connection.closeSignal;
+    }
+    get closed() {
+        return this.connection.closed;
+    }
+    get status() {
+        switch (this.webRtc.connectionState) {
+            case 'connected':
+                return ConnectionStatus.Connected;
+            case 'failed':
+            case 'closed':
+                return ConnectionStatus.Closed;
+            default:
+                return ConnectionStatus.Connecting;
+        }
+    }
+    waitForConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const onConnectionStateChanged = () => {
+                    const status = this.status;
+                    if (status === ConnectionStatus.Connecting)
+                        return;
+                    this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
+                    if (status === ConnectionStatus.Connected) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('connection closed'));
+                    }
+                };
+                this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
+                onConnectionStateChanged();
+            });
+        });
+    }
+    constructor(id, address, url, onDatagram, connection, webRtc) {
+        this.id = id;
+        this.address = address;
+        this.url = url;
+        this.onDatagram = onDatagram;
+        this.connection = connection;
+        this.webRtc = webRtc;
+        this._PeerIdMap = new WeakMap();
+        this._LocalVideos = new Map();
+        this._RemoteVideos = new Map();
+        this._Negotiation = { requested: false, running: false };
+        this._awaitingRemoteTracks = new Map();
+        logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor()');
+        this.closeSignal.addEventListener('abort', () => this._CleanUp(), {
+            once: true,
+        });
+        this._ClosePromise = new Promise((accept) => {
+            this.closeSignal.addEventListener('abort', () => {
+                logger.debug(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor(): _ClosePromise aborted');
+                accept('closed');
+            }, {
+                once: true,
+            });
+        });
+        this._AudioChannel = this.webRtc.createDataChannel('audio', {
+            id: 2,
+            negotiated: true,
+            ordered: false,
+            maxRetransmits: 0,
+        });
+        this._AudioChannel.binaryType = 'arraybuffer';
+        this._AudioChannel.onmessage = (event) => onDatagram(this.id, new Uint8Array(event.data));
+        this.webRtc.onicecandidate = this._OnIceCandidate.bind(this);
+        this.webRtc.onconnectionstatechange = () => this._OnWebRtcStatusChanged();
+        this.webRtc.ontrack = this.onTrack.bind(this);
+        this._SendOffer();
+        if (MainConnectionPingInterval !== undefined) {
+            this._PeriodicHealthCheck = setInterval(() => this.healthCheck(), MainConnectionPingInterval);
+        }
+        this._readWebRtcUpdate();
+    }
+    close() {
+        console.debug('MainConnection close(): ', this._PeerIdMap);
+        logger.log(['WebRTC', 'Connection'], 'MainConnection close(): ', this._PeerIdMap);
+        this.connection.close();
+    }
+    joinRoom(token, roomId, userData, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.joinRoom()');
+            const response = yield this.connection.request('JoinRoom', {
+                token: String(token),
+                room_id: roomId,
+                user_data: userData,
+                position,
+            });
+            if (response === 'closed' || response.type === 'Failure')
+                return response;
+            const responseValue = response.value;
+            if (!('token' in responseValue)) {
+                return failure('JoinRoom responded without token');
+            }
+            const url = extendUrl(this.url, `room?token=${responseValue.token}`);
+            if (url.type === 'Failure')
+                return url;
+            const webSocket = yield connect(url.value, this.closeSignal);
+            if (webSocket.type === 'Success') {
+                this._PeerIdMap.set(webSocket.value, responseValue.peer_id);
+                return success(new RpcConnection(webSocket.value));
+            }
+            else {
+                return webSocket;
+            }
+        });
+    }
+    getReconnectToken(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._Request('RequestReconnectToken', {
+                peer_id: peerId,
+            });
+            if (response.type === 'Failure')
+                return response;
+            return Token.parse(response.value);
+        });
+    }
+    sendDatagram(datagram) {
+        if (this._AudioChannel.readyState === 'open') {
+            this._AudioChannel.send(datagram);
+        }
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._Request('Ping', {}, HealthCheckTimeout);
+            const success = response !== 'timeout' && response.type === 'Success';
+            if (!success)
+                this.close();
+            return success;
+        });
+    }
+    _Request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield (timeout === undefined
+                ? this.connection.request(name, properties)
+                : this.connection.request(name, properties, timeout));
+            if (result === 'closed')
+                return failure('connection lost');
+            return result;
+        });
+    }
+    _readWebRtcUpdate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                const event = yield this.connection.recv();
+                if (event === 'closed')
+                    break;
+                if (event.name === 'WebRtcUpdate') {
+                    this._OnWebRtcUpdate(event.properties);
+                }
+            }
+            this.close();
+        });
+    }
+    _SendOffer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.ensureTransceivers();
+            try {
+                const offer = yield this.webRtc.createOffer();
+                assert(offer.type === 'offer' && offer.sdp, 'Generated broken webrtc offer');
+                yield this.webRtc.setLocalDescription(offer);
+                const sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
+                const media_map = [];
+                for (const [media_id, { transceiver }] of this._LocalVideos) {
+                    media_map.push([media_id, transceiver.mid]);
+                }
+                logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): media_map', media_map);
+                yield this._Request('WebRtcUpdate', {
+                    kind: 'Sdp',
+                    type: 'Offer',
+                    sdp,
+                    media_map,
+                });
+            }
+            catch (_b) {
+                logger.error(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): Failed creating an offer');
+            }
+        });
+    }
+    _OnWebRtcStatusChanged() {
+        logger.info(['WebRTC', 'Connection'], `WebRtcMainConnection._OnWebRtcStatusChanged(): ${this.webRtc.connectionState}`);
+        switch (this.webRtc.connectionState) {
+            case 'closed':
+            case 'failed':
+                this.close();
+                break;
+            case 'connected':
+                clearTimeout(this._WebRtcIceTimeout);
+                this._WebRtcIceTimeout = undefined;
+                clearTimeout(this._WebRtcTimeout);
+                this._WebRtcTimeout = undefined;
+                break;
+            case 'disconnected':
+                if (typeof MainConnectionPingInterval !== 'undefined') {
+                    this.healthCheck().then();
+                }
+            // falls through
+            default:
+                if (this._WebRtcIceTimeout === undefined) {
+                    // Gets removed after successfully connected
+                    this._WebRtcIceTimeout = setTimeout(() => {
+                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcIceTimeout was reached');
+                        this.webRtc.restartIce();
+                        this._WebRtcIceTimeout = undefined;
+                    }, WebRtcIceTimeout);
+                }
+                // Gets removed after successfully connected
+                if (this._WebRtcTimeout === undefined) {
+                    this._WebRtcTimeout = setTimeout(() => {
+                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcTimeout was reached');
+                        this.close();
+                    }, WebRtcTimeout);
+                }
+                break;
+        }
+    }
+    _OnWebRtcUpdate(update) {
+        switch (update.kind) {
+            case 'Sdp':
+                this._UpdateRemoteSdp(update);
+                break;
+            case 'Trickle':
+                this._AddIceCandidate(update);
+                break;
+            case 'TrickleFinished':
+                this.webRtc.addIceCandidate(undefined);
+                break;
+        }
+    }
+    _UpdateRemoteSdp(update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): update.media_map, this._RemoteVideos', update.media_map, this._RemoteVideos);
+            let remoteChanged = false;
+            for (const [media_id, mid] of update.media_map) {
+                const entry = this._RemoteVideos.get(media_id);
+                if ((entry === null || entry === void 0 ? void 0 : entry.state) === 'Requested') {
+                    remoteChanged = true;
+                    this._RemoteVideos.set(media_id, {
+                        state: 'Mapped',
+                        mid,
+                        promise: entry.promise,
+                    });
+                }
+            }
+            const type = update.type === 'Answer' ? 'answer' : 'offer';
+            // Set runnig to false
+            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): remoteChanged: ', remoteChanged);
+            (_a = this._ResolveOffer) === null || _a === void 0 ? void 0 : _a.call(this, true);
+            yield this.webRtc.setRemoteDescription({ type, sdp: update.sdp });
+        });
+    }
+    _AddIceCandidate(candidate) {
+        var _a, _b, _c;
+        const candidateInit = {
+            candidate: candidate.candidate,
+            sdpMid: (_a = candidate.spd_mid) !== null && _a !== void 0 ? _a : undefined,
+            sdpMLineIndex: (_b = candidate.spd_mline_index) !== null && _b !== void 0 ? _b : undefined,
+            usernameFragment: (_c = candidate.username_fragment) !== null && _c !== void 0 ? _c : undefined,
+        };
+        // HACK/TODO(max): find out why the server is not sending sdpMid or sdpMLineIndex
+        if (candidateInit.sdpMid === undefined &&
+            candidateInit.sdpMLineIndex === undefined) {
+            candidateInit.sdpMid = '0';
+        }
+        this.webRtc.addIceCandidate(candidateInit);
+    }
+    _OnIceCandidate(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (event.candidate) {
+                const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = event.candidate;
+                this._Request('WebRtcUpdate', {
+                    kind: 'Trickle',
+                    candidate,
+                    spd_mid: sdpMid !== null && sdpMid !== void 0 ? sdpMid : undefined,
+                    spd_mline_index: sdpMLineIndex !== null && sdpMLineIndex !== void 0 ? sdpMLineIndex : undefined,
+                    username_fragment: usernameFragment !== null && usernameFragment !== void 0 ? usernameFragment : undefined,
+                });
+            }
+            else {
+                this._Request('WebRtcUpdate', { kind: 'TrickleFinished' });
+            }
+        });
+    }
+    ensureTransceivers() {
+        const needed = this._LocalVideos.size + this._RemoteVideos.size;
+        const available = this.webRtc.getTransceivers().length;
+        for (let i = available; i < needed; i++) {
+            this.webRtc.addTransceiver('video');
+        }
+    }
+    startLocalVideo(mediaId, track) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert(!this._LocalVideos.has(mediaId), `No LocalVideo with mediaID ${mediaId}`);
+            logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): ', mediaId);
+            let transceiver = this.webRtc
+                .getTransceivers()
+                .find((transceiver) => transceiver.sender.track === track);
+            if (transceiver) {
+                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): Transceiver found -> replaceTrack.');
+                yield transceiver.sender.replaceTrack(track);
+            }
+            else {
+                const sender = this.webRtc.addTrack(track);
+                transceiver = this.webRtc
+                    .getTransceivers()
+                    .find((transceiver) => transceiver.sender === sender);
+                assert(transceiver, '');
+            }
+            this._LocalVideos.set(mediaId, { transceiver });
+            this.requestNegotiation(false);
+        });
+    }
+    stopLocalVideo(mediaId) {
+        const localVideo = this._LocalVideos.get(mediaId);
+        if (!localVideo)
+            return;
+        localVideo.transceiver.sender.track.enabled = false;
+        this._LocalVideos.delete(mediaId);
+        this.requestNegotiation(false);
+    }
+    startRemoteVideo(mediaId) {
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startRemoteVideo()');
+        this.requestNegotiation(true);
+        return new Promise((resolve, reject) => {
+            this._RemoteVideos.set(mediaId, {
+                state: 'Requested',
+                promise: { resolve, reject },
+            });
+        });
+    }
+    stopRemoteVideo(mediaId) {
+        const video = this._RemoteVideos.get(mediaId);
+        if (!video)
+            return;
+        this._RemoteVideos.delete(mediaId);
+        if (video.state !== 'Active') {
+            video.promise.reject(new Error('video stopped'));
+        }
+        this.requestNegotiation(false);
+    }
+    onTrack(event) {
+        // If there was no entry found, store the track until a remote Video was started.
+        // When starting a remote Video, check if there is already a track available.
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): RemoteVideos: ', this._RemoteVideos);
+        const entry = Array.from(this._RemoteVideos).find((video) => {
+            return (video[1].state === 'Mapped' && video[1].mid === event.transceiver.mid);
+        });
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): Found the RemoteVideo', entry);
+        if (entry === undefined) {
+            logger.warn(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Unexpected track(mid: ${event.transceiver.mid})`);
+            return;
+        }
+        const [media_id, video] = entry;
+        assert(video.state === 'Mapped', '');
+        this._RemoteVideos.set(media_id, {
+            state: 'Active',
+            transceiver: event.transceiver,
+        });
+        event.track.onended = () => logger.debug(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Track ended ${event.transceiver.mid}`, entry);
+        video.promise.resolve(event.track);
+    }
+    requestNegotiation(waitForAnswer) {
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation():');
+        this._Negotiation.requested = true;
+        if (this._Negotiation.running)
+            return;
+        this._Negotiation.running = true;
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            this._Negotiation.requested = false;
+            try {
+                yield this._SendOffer();
+                if (waitForAnswer) {
+                    yield new Promise((resolve) => {
+                        this._ResolveOffer = resolve;
+                    });
+                }
+            }
+            finally {
+                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation(): Finally');
+                this._Negotiation.running = false;
+                // @TODO Check if the retry is still needed.
+                const retry = Array.from(this._RemoteVideos).find((video) => {
+                    return video[1].state === 'Requested';
+                });
+                if (this._Negotiation.requested) {
+                    this.requestNegotiation(waitForAnswer);
+                }
+            }
+        }));
+    }
+    _CleanUp() {
+        console.debug(`${this.url} closed`);
+        this.connection.close();
+        this.webRtc.close();
+        clearInterval(this._PeriodicHealthCheck);
+        clearTimeout(this._WebRtcIceTimeout);
+        clearTimeout(this._WebRtcTimeout);
+    }
+}

package/lib/plugin/webrtc/websocket.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '@4players/odin-common';
+export declare function connect(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
+export declare function connectOnce(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;

package/lib/plugin/webrtc/websocket.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ConnectInterval } from '../config';
+import { abortableSleep, failure, success, } from '@4players/odin-common';
+export function connect(url, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = performance.now();
+        let connection = failure('no connection was attempted');
+        for (let failures = 0; failures < ConnectInterval.length && !signal.aborted; failures++) {
+            const nextReconnectAt = start + whenToConnect(failures);
+            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
+                'aborted') {
+                return failure('aborted');
+            }
+            connection = yield connectOnce(url, signal);
+            if (connection.type === 'Success') {
+                return connection;
+            }
+        }
+        return connection;
+    });
+}
+export function connectOnce(url, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let webSocket;
+        try {
+            webSocket = new WebSocket(url);
+        }
+        catch (reason) {
+            return failure(`unable to create websocket; ${reason}`);
+        }
+        const abort = new AbortController();
+        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
+            signal: abort.signal,
+        }));
+        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
+        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
+            signal: abort.signal,
+        }));
+        const result = yield Promise.race([onOpen, onClose, onAbort]);
+        abort.abort();
+        return result;
+    });
+}
+function whenToConnect(failures) {
+    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
+    const interval = ConnectInterval[failures] * Math.random();
+    return past_connects + interval;
+}

package/lib/worker/buffers.d.ts

@@ -0,0 +1,42 @@
+import type { OdinWasm } from '../../lib/wasm';
+export interface SampleBuffer {
+    readonly headers: Int32Array;
+    readonly samples: Float32Array;
+    readonly length: number;
+    readonly sampleRate: number;
+    readonly stereo: boolean;
+}
+export interface SampleBufferHeader {
+    id: number;
+}
+export declare function createSampleBuffer(wasm: typeof OdinWasm, sampleRate: number, length: number, stereo: boolean): SampleBuffer;
+export declare function freeSampleBuffer(wasm: typeof OdinWasm, buffer: SampleBuffer): void;
+export declare function samplesPerEntry(buffer: {
+    sampleRate: number;
+    stereo: boolean;
+}): number;
+export declare function getSamples(buffer: SampleBuffer, index: number): Float32Array;
+export declare function getHeader(buffer: SampleBuffer, index: number): SampleBufferHeader;
+export declare function setHeader(buffer: SampleBuffer, index: number, header: SampleBufferHeader): void;
+export interface DecoderInformationBuffer {
+    readonly values: Float32Array;
+    readonly length: number;
+}
+export declare function createDecoderInformationBuffer(wasm: typeof OdinWasm, length: number): DecoderInformationBuffer;
+export declare function freeDecoderInformationBuffer(wasm: typeof OdinWasm, buffer: DecoderInformationBuffer): void;
+export declare function getGlobalDecoderVolume(buffer: DecoderInformationBuffer): number;
+export declare function setGlobalDecoderVolume(buffer: DecoderInformationBuffer, value: number): void;
+export declare function getDecoderRmsDBFS(buffer: DecoderInformationBuffer, index: number): number;
+export declare function setDecoderRmsDBFS(buffer: DecoderInformationBuffer, index: number, value: number): void;
+export declare function getDecoderVolume(buffer: DecoderInformationBuffer, index: number): number;
+export declare function setDecoderVolume(buffer: DecoderInformationBuffer, index: number, value: number): void;
+export interface EncoderInformationBuffer {
+    readonly values: Float32Array;
+}
+export declare function createEncoderInformationBuffer(wasm: typeof OdinWasm): EncoderInformationBuffer;
+export declare function freeEncoderInformationBuffer(wasm: typeof OdinWasm, buffer: EncoderInformationBuffer): void;
+export declare function getEncoderActive(buffer: EncoderInformationBuffer): boolean;
+export declare function getEncoderSpeechProbability(buffer: EncoderInformationBuffer): number;
+export declare function getEncoderRmsDBFS(buffer: EncoderInformationBuffer): number;
+export declare function getEncoderVolume(buffer: EncoderInformationBuffer): number;
+export declare function setEncoderVolume(buffer: EncoderInformationBuffer, value: number): number;

package/lib/worker/buffers.js

@@ -0,0 +1,79 @@
+import { free, malloc } from './memory';
+export function createSampleBuffer(wasm, sampleRate, length, stereo) {
+    return {
+        headers: malloc(wasm, 'i32', length),
+        samples: malloc(wasm, 'f32', length * samplesPerEntry({ sampleRate, stereo })),
+        length,
+        sampleRate,
+        stereo,
+    };
+}
+export function freeSampleBuffer(wasm, buffer) {
+    free(wasm, buffer.headers);
+    free(wasm, buffer.samples);
+}
+export function samplesPerEntry(buffer) {
+    return buffer.sampleRate * 0.02 * (buffer.stereo ? 2 : 1);
+}
+export function getSamples(buffer, index) {
+    const size = samplesPerEntry(buffer);
+    const begin = size * index;
+    const end = begin + size;
+    return buffer.samples.subarray(begin, end);
+}
+export function getHeader(buffer, index) {
+    return { id: buffer.headers[index] };
+}
+export function setHeader(buffer, index, header) {
+    buffer.headers[index] = header.id;
+}
+export function createDecoderInformationBuffer(wasm, length) {
+    return {
+        values: malloc(wasm, 'f32', 1 + length * 2),
+        length,
+    };
+}
+export function freeDecoderInformationBuffer(wasm, buffer) {
+    free(wasm, buffer.values);
+}
+export function getGlobalDecoderVolume(buffer) {
+    return buffer.values[0];
+}
+export function setGlobalDecoderVolume(buffer, value) {
+    buffer.values[0] = value;
+}
+export function getDecoderRmsDBFS(buffer, index) {
+    return buffer.values[1 + index * 2];
+}
+export function setDecoderRmsDBFS(buffer, index, value) {
+    buffer.values[1 + index * 2] = value;
+}
+export function getDecoderVolume(buffer, index) {
+    return buffer.values[1 + index * 2 + 1];
+}
+export function setDecoderVolume(buffer, index, value) {
+    buffer.values[1 + index * 2 + 1] = value;
+}
+export function createEncoderInformationBuffer(wasm) {
+    return {
+        values: malloc(wasm, 'f32', 4),
+    };
+}
+export function freeEncoderInformationBuffer(wasm, buffer) {
+    free(wasm, buffer.values);
+}
+export function getEncoderActive(buffer) {
+    return buffer.values[0] !== 0;
+}
+export function getEncoderSpeechProbability(buffer) {
+    return buffer.values[1];
+}
+export function getEncoderRmsDBFS(buffer) {
+    return buffer.values[2];
+}
+export function getEncoderVolume(buffer) {
+    return buffer.values[3];
+}
+export function setEncoderVolume(buffer, value) {
+    return (buffer.values[3] = value);
+}

package/{worker/lib/index.d.ts → lib/worker/common.d.ts}

@@ -1,9 +1,8 @@
-export type CaptureSink = (connectionId: number, packet: Uint8Array) => void;
 export interface Activity {
     isSilent: boolean;
     rmsDBFS: number;
 }
-export declare const silence: Activity;
+export declare const Silence: Activity;
 export interface VadConfig {
     volumeGate?: {
         attackThreshold: number;
@@ -14,6 +13,7 @@ export interface VadConfig {
         releaseThreshold: number;
     };
 }
+export type CaptureSink = (connectionId: number, packet: Uint8Array) => void;
 export interface CaptureWorker {
     readonly worklet: AudioWorkletNode;
     readonly worker: Worker;
@@ -28,11 +28,6 @@ export interface CaptureWorker {
     setVad(config: VadConfig): void;
     close(): void;
 }
-export declare function createCaptureWorker(context: AudioContext, sink: CaptureSink, refreshRate?: number): Promise<CaptureWorker>;
-export interface PlaybackId {
-    connectionId: number;
-    mediaId: number;
-}
 export interface PlaybackWorker {
     readonly audioContext: AudioContext;
     receivePacket(connectionId: number, packet: Uint8Array): void;
@@ -43,4 +38,8 @@ export interface PlaybackWorker {
     setVolume(id: PlaybackId, value: number): void;
     close(): void;
 }
-export declare function createPlaybackWorker(audioContext: AudioContext, refreshRate?: number): Promise<PlaybackWorker>;
+export interface PlaybackId {
+    connectionId: number;
+    mediaId: number;
+}
+export declare function mergeIds(id: PlaybackId): number;