@4players/odin-plugin-web 1.0.0-alpha.8 → 1.0.0-alpha.9

package/lib/plugin/audioController.d.ts

@@ -1,7 +1,7 @@
 import { Backend, Strand } from '@4players/odin-common';
 import { DeviceParameters } from '.';
-import { CaptureSink, PlaybackId, PlaybackWorker } from '../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,6 +48,12 @@ export declare class AudioController {
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
     enumerateDevices(): Promise<Device[]>;
+    /**
+     * 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;
@@ -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("../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/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 '../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,6 +120,7 @@ export class AudioController {
     }
     enumerateDevices() {
         return __awaiter(this, void 0, void 0, function* () {
+            hasAudioPermissions = yield this._requestMediaPermissions();
             const mediaDeviceInfos = yield navigator.mediaDevices.enumerateDevices();
             const devices = [];
             let outputDeviceIndex = 0;
@@ -145,6 +148,43 @@ export class AudioController {
             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();
+                });
+            }
+            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;
@@ -155,13 +195,19 @@ export class AudioController {
             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 && device && audioContext.state === 'running') {
+            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);
             }
         }));
@@ -197,8 +243,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;
@@ -284,7 +330,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;
@@ -429,6 +475,7 @@ function openCaptureDevice(controller, parameters, apm) {
             ]);
             if (result === 'timeout')
                 return failure('getUserMedia; timeout');
+            hasAudioPermissions = true;
             stream = result;
         }
         catch (reason) {
@@ -439,4 +486,3 @@ function openCaptureDevice(controller, parameters, apm) {
         return success(context.createMediaStreamSource(stream));
     });
 }
-//# sourceMappingURL=audioController.js.map

package/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/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/lib/plugin/connectionPool.d.ts

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

package/lib/plugin/connectionPool.js

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

package/lib/plugin/index.d.ts

@@ -50,4 +50,3 @@ export declare class Room implements Backend.Room {
     private _HandleMediaStart;
     private _HandleMediaStopped;
 }
-//# sourceMappingURL=index.d.ts.map

package/lib/plugin/index.js

@@ -290,4 +290,3 @@ export class Room {
         peer.mediaIds.delete(mediaId);
     }
 }
-//# sourceMappingURL=index.js.map

package/lib/plugin/mainConnection.d.ts

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

package/lib/plugin/mainConnection.js

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

package/lib/plugin/roomConnection.d.ts

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

package/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/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/lib/plugin/rpcConnection.js

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

package/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/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/lib/worker/common.d.ts

@@ -1,28 +1,45 @@
-import { Result } from '@4players/odin-common';
-import type { OdinWasm } from '../../lib/wasm';
-import type { PlaybackId } from './index';
-export declare const PlaybackPreload = 3;
-export declare const DefaultRefreshRate = 250;
-export declare const VadPreload = 3;
-export declare const MaxNumberOfDecoders = 512;
-export declare const MinDBFs = -758.596;
-export declare function malloc(wasm: typeof OdinWasm, element: 'f32', length: number): Float32Array;
-export declare function malloc(wasm: typeof OdinWasm, element: 'u32', length: number): Uint32Array;
-export declare function malloc(wasm: typeof OdinWasm, element: 'i32', length: number): Int32Array;
-export declare function malloc(wasm: typeof OdinWasm, element: 'u8', length: number): Uint8Array;
-export declare function free(wasm: typeof OdinWasm, array: Float32Array): void;
-export declare function free(wasm: typeof OdinWasm, array: Uint32Array): void;
-export declare function free(wasm: typeof OdinWasm, array: Int32Array): void;
-export declare function free(wasm: typeof OdinWasm, array: Uint8Array): void;
-export declare function mergeIds(id: PlaybackId): number;
-export declare class Packet {
-    readonly mediaIds: number[];
-    readonly sequenceNumber: number;
-    readonly timeStamp: number;
-    readonly isEndOfSpurt: boolean;
-    readonly payload: Uint8Array;
-    static parse(bytes: Uint8Array): Result<Packet>;
-    constructor(mediaIds: number[], sequenceNumber: number, timeStamp: number, isEndOfSpurt: boolean, payload: Uint8Array);
-    toBytes(): Uint8Array;
+export interface Activity {
+    isSilent: boolean;
+    rmsDBFS: number;
+}
+export declare const Silence: Activity;
+export interface VadConfig {
+    volumeGate?: {
+        attackThreshold: number;
+        releaseThreshold: number;
+    };
+    voiceActivity?: {
+        attackThreshold: number;
+        releaseThreshold: number;
+    };
+}
+export type CaptureSink = (connectionId: number, packet: Uint8Array) => void;
+export interface CaptureWorker {
+    readonly worklet: AudioWorkletNode;
+    readonly worker: Worker;
+    get context(): BaseAudioContext;
+    get activity(): Activity;
+    get speechProbability(): number;
+    setMedias(connections: Array<{
+        id: number;
+        mediaIds: number[];
+    }>): void;
+    setVolume(value: number): void;
+    setVad(config: VadConfig): void;
+    close(): void;
 }
-//# sourceMappingURL=common.d.ts.map
+export interface PlaybackWorker {
+    readonly audioContext: AudioContext;
+    receivePacket(connectionId: number, packet: Uint8Array): void;
+    addMedias(connectionId: number, mediaIds: number[]): void;
+    removeMedias(connectionId: number, mediaIds: number[]): void;
+    getActivity(id: PlaybackId): Activity | undefined;
+    setGlobalVolume(value: number): void;
+    setVolume(id: PlaybackId, value: number): void;
+    close(): void;
+}
+export interface PlaybackId {
+    connectionId: number;
+    mediaId: number;
+}
+export declare function mergeIds(id: PlaybackId): number;

package/lib/worker/common.js

@@ -1,100 +1,7 @@
-/* eslint-disable no-redeclare */
-import { failure, success } from '@4players/odin-common';
-import * as msgpack from '@msgpack/msgpack';
-export const PlaybackPreload = 3;
-export const DefaultRefreshRate = 250;
-export const VadPreload = 3;
-export const MaxNumberOfDecoders = 512;
-export const MinDBFs = -758.596;
-export function malloc(wasm, element, length) {
-    let heap;
-    switch (element) {
-        case 'f32':
-            heap = wasm.HEAPF32;
-            break;
-        case 'u32':
-            heap = wasm.HEAPU32;
-            break;
-        case 'i32':
-            heap = wasm.HEAP32;
-            break;
-        case 'u8':
-            heap = wasm.HEAPU8;
-            break;
-        default:
-            throw new Error(`allocating ${element} is not supported`);
-    }
-    const pointer = wasm._malloc(length * heap.BYTES_PER_ELEMENT);
-    if (pointer === 0 || pointer % heap.BYTES_PER_ELEMENT !== 0) {
-        throw new Error(`failed allocating a ${length} ${element} array`);
-    }
-    const start = pointer / heap.BYTES_PER_ELEMENT;
-    return heap.subarray(start, start + length);
-}
-export function free(wasm, array) {
-    wasm._free(array.byteOffset);
-}
+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;
 }
-export class Packet {
-    static parse(bytes) {
-        let parsed;
-        try {
-            parsed = msgpack.decode(bytes);
-        }
-        catch (error) {
-            return failure('not valid msgpack');
-        }
-        if (!Array.isArray(parsed))
-            return failure('container must be an array');
-        if (parsed.length < 6)
-            return failure('missing fields');
-        if (parsed[0] !== 1)
-            return failure('unknown type');
-        if (!Array.isArray(parsed[1]))
-            return failure('media ids must be an array');
-        if (!parsed[1].every((entry) => typeof entry === 'number')) {
-            return failure('media ids must be numbers');
-        }
-        if (typeof parsed[2] !== 'number') {
-            return failure('sequence number must be a number');
-        }
-        if (typeof parsed[3] !== 'number') {
-            return failure('timestamp must be a number');
-        }
-        if (typeof parsed[4] !== 'number')
-            return failure('flags must be a number');
-        const mediaIds = parsed[1];
-        const sequenceNumber = parsed[2] >>> 0;
-        const timeStamp = parsed[3] >>> 0;
-        const flags = parsed[4];
-        const isEndOfSpurt = (flags & 0x01) !== 0;
-        const payload = parsed[parsed.length - 1];
-        if (!(payload instanceof Uint8Array)) {
-            return failure('payload must be bytes');
-        }
-        return success(new Packet(mediaIds, sequenceNumber, timeStamp, isEndOfSpurt, payload));
-    }
-    constructor(mediaIds, sequenceNumber, timeStamp, isEndOfSpurt, payload) {
-        this.mediaIds = mediaIds;
-        this.sequenceNumber = sequenceNumber;
-        this.timeStamp = timeStamp;
-        this.isEndOfSpurt = isEndOfSpurt;
-        this.payload = payload;
-    }
-    toBytes() {
-        const flags = Number(this.isEndOfSpurt);
-        return msgpack.encode([
-            1,
-            this.mediaIds,
-            this.sequenceNumber >>> 0,
-            this.timeStamp >>> 0,
-            flags,
-            this.payload,
-        ]);
-    }
-}
-//# sourceMappingURL=common.js.map

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;

package/lib/worker/config.js

@@ -0,0 +1,11 @@
+// shared
+export const AdditionalPlaybackBlocks = 3;
+export const AdditionalCaptureBlocks = 3;
+// unshared
+export const PlaybackPreload = 3;
+export const DefaultRefreshRate = 250;
+// both
+export const VadPreload = 3;
+export const MaxNumberOfDecoders = 512;
+export const RenderQuantumSize = 128;
+export const MinDBFs = -758.596;