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

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

@@ -1,5 +1,5 @@
 import { Result } from '@4players/odin-common';
-import type { OdinWasm } from '@4players/odin-plugin-web-wasm';
+import type { OdinWasm } from '../../lib/wasm';
 import type { PlaybackId } from './index';
 export declare const PlaybackPreload = 3;
 export declare const DefaultRefreshRate = 250;
@@ -25,3 +25,4 @@ export declare class Packet {
     constructor(mediaIds: number[], sequenceNumber: number, timeStamp: number, isEndOfSpurt: boolean, payload: Uint8Array);
     toBytes(): Uint8Array;
 }
+//# sourceMappingURL=common.d.ts.map

package/lib/worker/common.js

@@ -0,0 +1,100 @@
+/* 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/{worker/lib → lib/worker}/index.d.ts

@@ -44,3 +44,4 @@ export interface PlaybackWorker {
     close(): void;
 }
 export declare function createPlaybackWorker(audioContext: AudioContext, refreshRate?: number): Promise<PlaybackWorker>;
+//# sourceMappingURL=index.d.ts.map