@4players/odin-plugin-web 1.0.0-alpha.1 → 1.0.0-alpha.11

package/README.md

@@ -1,28 +1,28 @@
+# @4players/odin-plugin-web
 
-## Description
+[![npm](https://img.shields.io/npm/v/@4players/odin-plugin-web.svg)][npm-badge-url]
+[![npm](https://img.shields.io/npm/l/@4players/odin-plugin-web.svg)][license-url]
+[![npm](https://img.shields.io/npm/dm/@4players/odin-plugin-web.svg)][npm-badge-url]
 
-Eyvor is browser-based backend for the odin-sdk.
+A backend plugin for the [@4players/odin](https://www.npmjs.com/package/@4players/odin) SDK package supporting web browsers.
 
-## How to Setup
+## Troubleshooting
 
-We use [asdf](https://asdf-vm.com/) to manage our toolchain.
+Contact us through the listed methods below to receive answers to your questions and learn more about ODIN.
 
-### Install Toolchain
+### Discord
 
-```bash
-asdf plugin add nodejs
-asdf plugin add emsdk
-asdf install
-```
+Join our official Discord server to chat with us directly and become a part of the 4Players ODIN community.
 
-### Build
+[![Join us on Discord](https://developers.4players.io/images/join_discord.png)](https://4np.de/discord)
 
-```
-npm run build
-```
+### Twitter
 
-### Test
+Have a quick question? Tweet us at [@ODIN4Players](https://twitter.com/ODIN4Players) and we’ll help you resolve any issues.
 
-```
-npm run test
-```
+### Email
+
+Don’t use Discord or Twitter? Send us an [email](mailto:odin@4players.io) and we’ll get back to you as soon as possible.
+
+[npm-badge-url]: https://www.npmjs.com/package/@4players/odin-plugin-web
+[license-url]: https://github.com/4Players/odin-sdk-web/blob/master/LICENSE

package/{backend/lib → lib/plugin}/audioController.d.ts

@@ -1,7 +1,7 @@
 import { Backend, Strand } from '@4players/odin-common';
 import { DeviceParameters } from '.';
-import { CaptureSink, PlaybackId, PlaybackWorker } from '@4players/odin-plugin-web-worker';
 import { RoomConnection } from './roomConnection';
+import { CaptureSink, PlaybackId, PlaybackWorker } from '../worker/common';
 export type Volume = Backend.Volume;
 export type Activity = Backend.Activity;
 export type CreateAudioPlaybackParameters = Backend.CreateAudioPlaybackParameters;
@@ -48,7 +48,13 @@ export declare class AudioController {
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
     enumerateDevices(): Promise<Device[]>;
-    playbackSetDevice(device: Device | undefined): Promise<void>;
+    /**
+     * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
+     * @private
+     * @throws
+     */
+    private _requestMediaPermissions;
+    playbackSetDevice(device?: Device): Promise<void>;
     playbackSetGlobalVolume(value: Backend.Volume): void;
     playbackStart(uid: string, id: GlobalMediaId): void;
     playbackStop(uid: string, id: GlobalMediaId): void;
@@ -60,10 +66,10 @@ export declare class AudioController {
 }
 export declare class Device implements Backend.Device {
     readonly device: MediaDeviceInfo;
-    constructor(device: MediaDeviceInfo);
+    readonly isDefault: boolean;
+    constructor(device: MediaDeviceInfo, isDefault?: boolean);
     get type(): "AudioPlayback" | "AudioCapture";
     get name(): string;
-    get isDefault(): boolean;
 }
 export declare class AudioPlayback implements Backend.AudioPlayback {
     readonly controller: AudioController;
@@ -87,7 +93,7 @@ export declare class AudioCapture implements Backend.AudioCapture {
     get vad(): Backend.VadConfig;
     get apm(): Backend.ApmConfig;
     get volume(): Backend.Volume;
-    get activity(): import("@4players/odin-plugin-web-worker").Activity;
+    get activity(): import("../worker/common").Activity;
     get speechProbability(): number;
     constructor(controller: AudioController, parameters: CreateAudioCaptureParameters);
     start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
@@ -99,4 +105,3 @@ export declare class AudioCapture implements Backend.AudioCapture {
     close(): void;
     _UpdateMedias(): Promise<void>;
 }
-//# sourceMappingURL=audioController.d.ts.map

package/{backend/lib → lib/plugin}/audioController.js

@@ -8,7 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Strand, assert, failure, sleep, success, } from '@4players/odin-common';
-import { createCaptureWorker, createPlaybackWorker, silence, } from '@4players/odin-plugin-web-worker';
+import { Silence, } from '../worker/common';
+import { createCaptureWorker, createPlaybackWorker } from '../worker';
 const defaultVad = {
     voiceActivity: {
         attackThreshold: 0.9,
@@ -76,6 +77,7 @@ export class AudioContextCollection {
         }
     }
 }
+let hasAudioPermissions = false;
 export class AudioController {
     create(audioContexts, sink) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -118,28 +120,95 @@ export class AudioController {
     }
     enumerateDevices() {
         return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield navigator.mediaDevices.enumerateDevices();
-            return devices
-                .filter((device) => device.kind === 'audioinput' || device.kind === 'audiooutput')
-                .map((device) => new Device(device));
+            hasAudioPermissions = yield this._requestMediaPermissions();
+            const mediaDeviceInfos = yield navigator.mediaDevices.enumerateDevices();
+            const devices = [];
+            let outputDeviceIndex = 0;
+            let inputDeviceIndex = 0;
+            for (const mediaDeviceInfo of mediaDeviceInfos) {
+                if (mediaDeviceInfo.kind === 'audioinput') {
+                    if (inputDeviceIndex === 0) {
+                        devices.push(new Device(mediaDeviceInfo, true));
+                    }
+                    else {
+                        devices.push(new Device(mediaDeviceInfo, false));
+                    }
+                    inputDeviceIndex++;
+                }
+                if (mediaDeviceInfo.kind === 'audiooutput') {
+                    if (outputDeviceIndex === 0) {
+                        devices.push(new Device(mediaDeviceInfo, true));
+                    }
+                    else {
+                        devices.push(new Device(mediaDeviceInfo, false));
+                    }
+                    outputDeviceIndex++;
+                }
+            }
+            return devices;
+        });
+    }
+    /**
+     * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
+     * @private
+     * @throws
+     */
+    _requestMediaPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (hasAudioPermissions)
+                return true;
+            const constraints = {};
+            constraints.audio = {
+                sampleRate: undefined,
+                deviceId: '',
+                autoGainControl: false,
+                noiseSuppression: false,
+                advanced: undefined,
+                aspectRatio: undefined,
+                echoCancellation: false,
+                channelCount: 0,
+                facingMode: undefined,
+                frameRate: 0,
+            };
+            console.log('Plugin _requestMediaPermissions: ', constraints);
+            try {
+                const ms = yield navigator.mediaDevices.getUserMedia(constraints);
+                ms === null || ms === void 0 ? void 0 : ms.getTracks().forEach((track) => {
+                    track.stop();
+                    ms.removeTrack(track);
+                });
+            }
+            catch (e) {
+                console.error(`Requesting permissions for ${'audio'} failed.`);
+                console.error(e);
+                return false;
+            }
+            return true;
         });
     }
     playbackSetDevice(device) {
         return this.setPlaybackStrand.enqueue(() => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const deviceId = (_a = device === null || device === void 0 ? void 0 : device.device.deviceId) !== null && _a !== void 0 ? _a : undefined;
+            let deviceId = (_a = device === null || device === void 0 ? void 0 : device.device.deviceId) !== null && _a !== void 0 ? _a : '';
+            if (deviceId === 'default') {
+                deviceId = '';
+            }
             let audioContext;
             if (this.playbackWorker === undefined) {
                 audioContext = yield this.audioContexts.acquire(48000);
+                console.log('playbackSetDevice: this.audioContexts.acquire(48000)');
                 this.playbackWorker = yield createPlaybackWorker(audioContext);
                 this.playbackWorker.setGlobalVolume(this.globalVolume);
             }
             else {
+                console.log('this.playbackWorker.audioContext');
                 audioContext = this.playbackWorker.audioContext;
             }
-            if (audioContext.setSinkId !== undefined &&
-                deviceId !== 'default' &&
-                deviceId) {
+            console.log('playbackSetDevice audioContext: ', audioContext);
+            if ((audioContext === null || audioContext === void 0 ? void 0 : audioContext.setSinkId) !== undefined &&
+                device &&
+                (audioContext === null || audioContext === void 0 ? void 0 : audioContext.state) === 'running') {
+                console.log('Browser audioContext.setSinkId');
                 yield audioContext.setSinkId(deviceId);
             }
         }));
@@ -175,8 +244,8 @@ export class AudioController {
         var _a, _b;
         const entry = this.playbacks.get(uid);
         if ((entry === null || entry === void 0 ? void 0 : entry.id) === undefined)
-            return silence;
-        return (_b = (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.getActivity(entry.id)) !== null && _b !== void 0 ? _b : silence;
+            return Silence;
+        return (_b = (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.getActivity(entry.id)) !== null && _b !== void 0 ? _b : Silence;
     }
     playbackSetVolume(uid, volume) {
         var _a;
@@ -208,8 +277,9 @@ export class AudioController {
     }
 }
 export class Device {
-    constructor(device) {
+    constructor(device, isDefault = false) {
         this.device = device;
+        this.isDefault = isDefault;
     }
     get type() {
         switch (this.device.kind) {
@@ -224,9 +294,6 @@ export class Device {
     get name() {
         return this.device.label;
     }
-    get isDefault() {
-        return false;
-    }
 }
 export class AudioPlayback {
     get volume() {
@@ -264,7 +331,7 @@ export class AudioCapture {
     }
     get activity() {
         var _a, _b;
-        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.activity) !== null && _b !== void 0 ? _b : silence;
+        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.activity) !== null && _b !== void 0 ? _b : Silence;
     }
     get speechProbability() {
         var _a, _b;
@@ -362,14 +429,22 @@ export class AudioCapture {
         });
     }
     setVolume(value) {
+        var _a;
         this._Volume = value;
-        if (this._Capture) {
-            this._Capture.worker.setVolume(value === 'muted' ? 0 : value);
+        if (value === 'muted') {
+            this.close();
+        }
+        else {
+            if (!this._Capture && this._deviceParameters) {
+                this.setDevice(this._deviceParameters);
+            }
+            (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.setVolume(value);
         }
     }
     close() {
         if (this._Capture !== undefined) {
             this._Capture.worker.close();
+            stopMediaStream(this._Capture.source.mediaStream);
             this._Capture.source.disconnect(this._Capture.worker.worklet);
             this.controller.audioContexts.release(this._Capture.source.context);
         }
@@ -386,6 +461,12 @@ export class AudioCapture {
         });
     }
 }
+function stopMediaStream(ms) {
+    ms.getTracks().forEach(track => {
+        track.stop();
+        ms.removeTrack(track);
+    });
+}
 function openCaptureDevice(controller, parameters, apm) {
     return __awaiter(this, void 0, void 0, function* () {
         const deviceId = parameters.device
@@ -409,6 +490,7 @@ function openCaptureDevice(controller, parameters, apm) {
             ]);
             if (result === 'timeout')
                 return failure('getUserMedia; timeout');
+            hasAudioPermissions = true;
             stream = result;
         }
         catch (reason) {
@@ -419,4 +501,3 @@ function openCaptureDevice(controller, parameters, apm) {
         return success(context.createMediaStreamSource(stream));
     });
 }
-//# sourceMappingURL=audioController.js.map

package/{backend/lib → lib/plugin}/config.d.ts

@@ -8,4 +8,3 @@ export declare const ConnectTimeout = 5000;
 export declare const MinTokenLifetime = 60000;
 export declare const MinTokenRefreshInterval = 5000;
 export declare const ConnectInterval: number[];
-//# sourceMappingURL=config.d.ts.map

package/{backend/lib → lib/plugin}/config.js

@@ -8,4 +8,3 @@ export const ConnectTimeout = 5000; /* ms */
 export const MinTokenLifetime = 60000; /* 1min */
 export const MinTokenRefreshInterval = 5000; /* 5sec */
 export const ConnectInterval = [0, 100, 200, 200, 500, 1000, 2000]; /* ms */
-//# sourceMappingURL=config.js.map

package/{backend/lib → lib/plugin}/connectionPool.d.ts

@@ -14,4 +14,3 @@ export declare class ConnectionPool {
     checkHealth(): Promise<void>;
     close(): void;
 }
-//# sourceMappingURL=connectionPool.d.ts.map

package/{backend/lib → lib/plugin}/connectionPool.js

@@ -108,4 +108,3 @@ export class ConnectionPool {
         this._Close.abort();
     }
 }
-//# sourceMappingURL=connectionPool.js.map

package/{backend/lib → lib/plugin}/index.d.ts

@@ -22,7 +22,7 @@ export declare class WebPlugin implements Backend.Plugin {
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
     enumerateDevices(): Promise<Device[]>;
     setOutputVolume(volume: Volume): void;
-    setOutputDevice(device: DeviceParameters): void;
+    setOutputDevice(device: DeviceParameters): Promise<void>;
     close(): void;
 }
 export declare class Room implements Backend.Room {
@@ -50,4 +50,3 @@ export declare class Room implements Backend.Room {
     private _HandleMediaStart;
     private _HandleMediaStopped;
 }
-//# sourceMappingURL=index.d.ts.map

package/{backend/lib → lib/plugin}/index.js

@@ -54,7 +54,9 @@ export class WebPlugin {
         this._AudioController.playbackSetGlobalVolume(volume);
     }
     setOutputDevice(device) {
-        this._AudioController.playbackSetDevice(device.device);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._AudioController.playbackSetDevice(device.device);
+        });
     }
     close() {
         this._AudioController.close();
@@ -288,4 +290,3 @@ export class Room {
         peer.mediaIds.delete(mediaId);
     }
 }
-//# sourceMappingURL=index.js.map

package/{backend/lib → lib/plugin}/mainConnection.d.ts

@@ -37,4 +37,3 @@ export declare class MainConnection {
     private _CleanUp;
 }
 export {};
-//# sourceMappingURL=mainConnection.d.ts.map

package/{backend/lib → lib/plugin}/mainConnection.js

@@ -291,4 +291,3 @@ export class MainConnection {
         clearTimeout(this._WebRtcTimeout);
     }
 }
-//# sourceMappingURL=mainConnection.js.map

package/{backend/lib → lib/plugin}/roomConnection.d.ts

@@ -34,4 +34,3 @@ export declare class RoomConnection {
     private _HandleRequests;
     private _RenewToken;
 }
-//# sourceMappingURL=roomConnection.d.ts.map

package/{backend/lib → lib/plugin}/roomConnection.js

@@ -122,20 +122,25 @@ export class RoomConnection {
     }
     _ConnectToServer() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._Token.hasAudience('sfu') || this._Token.address === undefined) {
+            // for now strip upstream wrappers in the token, because it not supported in web
+            let token = this._Token;
+            while (token.upstream !== undefined) {
+                token = token.upstream;
+            }
+            if (!token.hasAudience('sfu') || token.address === undefined) {
                 return success('continue');
             }
-            this._ChangeStatus('Joining', `connecting to ${this._Token.address}`);
+            this._ChangeStatus('Joining', `connecting to ${token.address}`);
             // are we already connected to the server?
             if (this._MainConnection === undefined ||
                 this._MainConnection.closed ||
-                this._MainConnection.url !== this._Token.address) {
+                this._MainConnection.url !== token.address) {
                 // no? release the not fitting connection
                 if (this._MainConnection) {
                     this.connectionPool.releaseConnection(this._MainConnection);
                 }
                 // connect to the right server
-                const mainConnection = yield this.connectionPool.acquireConnection(this._Token.address, this._Close.signal);
+                const mainConnection = yield this.connectionPool.acquireConnection(token.address, this._Close.signal);
                 if (mainConnection === 'closed')
                     return failure('connection pool closed'); // connection pool is closed
                 if (mainConnection.type === 'Failure') {
@@ -147,7 +152,7 @@ export class RoomConnection {
             // join room
             const result = yield Promise.race([
                 Promise.all([
-                    this._MainConnection.joinRoom(this._Token, this.roomId, this.userData, this.position),
+                    this._MainConnection.joinRoom(token, this.roomId, this.userData, this.position),
                 ]),
                 sleep(ConnectTimeout, 'timeout'),
                 this._Closed,
@@ -296,4 +301,3 @@ function contactGateway(gateway, token, signal) {
         }
     });
 }
-//# sourceMappingURL=roomConnection.js.map

package/{backend/lib → lib/plugin}/rpcConnection.d.ts

@@ -46,4 +46,3 @@ export declare class TypedRpcConnection<C extends Commands, E extends Events> ex
     notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
     recv(): Promise<RealizedEvents<E> | 'closed'>;
 }
-//# sourceMappingURL=rpcConnection.d.ts.map

package/{backend/lib → lib/plugin}/rpcConnection.js

@@ -232,4 +232,3 @@ export class TypedRpcConnection extends RpcConnection {
         });
     }
 }
-//# sourceMappingURL=rpcConnection.js.map

package/{backend/lib → lib/plugin}/token.d.ts

@@ -6,11 +6,12 @@ export declare class Token {
     readonly claims: TokenClaims;
     static parse(token: string): Result<Token>;
     private readonly _Address;
+    private readonly _Upstream;
     protected constructor(text: string, claims: TokenClaims);
     get timeLeft(): number;
     get address(): URL | undefined;
+    get upstream(): Token | undefined;
     get defaultRoomId(): string | undefined;
     hasAudience(audience: z.infer<typeof TokenAudienceSchema>): boolean;
     toString(): string;
 }
-//# sourceMappingURL=token.d.ts.map

package/{backend/lib → lib/plugin}/token.js

@@ -33,6 +33,15 @@ export class Token {
                 console.error(`address in token(${address}) can not be parsed; ${error}`);
             }
         }
+        if (claims.ups !== undefined) {
+            const upstream = Token.parse(claims.ups);
+            if (upstream.type === 'Success') {
+                this._Upstream = upstream.value;
+            }
+            else {
+                console.error(`upstream in token can not be parsed; ${upstream.reason}`);
+            }
+        }
     }
     get timeLeft() {
         if (this.claims.exp === undefined)
@@ -42,6 +51,9 @@ export class Token {
     get address() {
         return this._Address;
     }
+    get upstream() {
+        return this._Upstream;
+    }
     get defaultRoomId() {
         if (Array.isArray(this.claims.rid)) {
             return this.claims.rid.length === 1 ? this.claims.rid[0] : undefined;
@@ -64,4 +76,3 @@ export class Token {
         return this.text;
     }
 }
-//# sourceMappingURL=token.js.map

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;

package/lib/worker/common.js

@@ -0,0 +1,7 @@
+import { MinDBFs } from './config';
+export const Silence = { isSilent: true, rmsDBFS: MinDBFs };
+export function mergeIds(id) {
+    // connectionId is 21 Bits.
+    // mediaId is 32 Bits
+    return id.connectionId * 4294967296 + id.mediaId;
+}

package/lib/worker/config.d.ts

@@ -0,0 +1,8 @@
+export declare const AdditionalPlaybackBlocks = 3;
+export declare const AdditionalCaptureBlocks = 3;
+export declare const PlaybackPreload = 3;
+export declare const DefaultRefreshRate = 250;
+export declare const VadPreload = 3;
+export declare const MaxNumberOfDecoders = 512;
+export declare const RenderQuantumSize = 128;
+export declare const MinDBFs = -758.596;