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

package/lib/worker/common.d.ts

@@ -1,28 +0,0 @@
-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;
-}
-//# sourceMappingURL=common.d.ts.map

package/lib/worker/common.js

@@ -1,100 +0,0 @@
-/* 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);
-}
-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/index.d.ts

@@ -1,47 +0,0 @@
-export type CaptureSink = (connectionId: number, packet: Uint8Array) => void;
-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 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;
-}
-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;
-    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 declare function createPlaybackWorker(audioContext: AudioContext, refreshRate?: number): Promise<PlaybackWorker>;
-//# sourceMappingURL=index.d.ts.map