opus-codec 0.0.1

package/opus/Decoder.d.ts

@@ -0,0 +1,8 @@
+import { Runtime } from '../runtime';
+export default class Decoder {
+    #private;
+    constructor(runtime: Runtime, sampleRate: number, channels: number, frameSize: number);
+    decodeFloat(value: Uint8Array, decodeFec?: number): number;
+    decoded(): Float32Array;
+    destroy(): void;
+}

package/opus/Decoder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../runtime");
+class Decoder {
+    #errorPointer;
+    #error;
+    #decoder;
+    #holder;
+    #runtime;
+    #pcm;
+    #frameSize;
+    constructor(runtime, sampleRate, channels, frameSize) {
+        this.#frameSize = frameSize;
+        this.#runtime = runtime;
+        this.#holder = new runtime_1.ResourcesHolder();
+        this.#error = new runtime_1.Integer(runtime);
+        this.#errorPointer = new runtime_1.Pointer(runtime, this.#error);
+        /**
+         * holder
+         */
+        this.#holder.add(this.#error);
+        this.#holder.add(this.#errorPointer);
+        /**
+         * create decoder
+         */
+        this.#decoder = runtime.originalRuntime()._opus_decoder_create(sampleRate, channels, this.#errorPointer.offset());
+        if (!this.#decoder || this.#error.value() < 0) {
+            throw new Error('Failed to create decoder');
+        }
+        this.#pcm = new runtime_1.Buffer(runtime, this.#frameSize * channels * Float32Array.BYTES_PER_ELEMENT);
+    }
+    #data = null;
+    decodeFloat(value, decodeFec = 0) {
+        let data = this.#data;
+        if (!data) {
+            data = new runtime_1.Buffer(this.#runtime, value.byteLength);
+        }
+        /**
+         * reallocate in case current allocated buffer is smaller than the actual
+         * incoming data
+         */
+        if (data.data().byteLength < value.byteLength) {
+            data.destroy();
+            data = new runtime_1.Buffer(this.#runtime, value.byteLength);
+        }
+        /**
+         * set data
+         */
+        data.data().set(value);
+        /**
+         * in case the data buffer has changed, set it back to the class
+         * instance so we can later destroy it
+         */
+        this.#data = data;
+        /**
+         * decode float data
+         */
+        const decodedSamples = this.#runtime.originalRuntime()._opus_decode_float(this.#decoder, data.offset(), value.byteLength, this.#pcm.offset(), this.#frameSize, decodeFec);
+        if (decodedSamples < 0) {
+            throw new Error('Failed to decode float');
+        }
+        return decodedSamples;
+    }
+    decoded() {
+        const pcm = this.#pcm.data();
+        return new Float32Array(pcm.buffer, pcm.byteOffset, pcm.byteLength / Float32Array.BYTES_PER_ELEMENT);
+    }
+    destroy() {
+        this.#runtime.originalRuntime()._opus_decoder_destroy(this.#decoder);
+        this.#holder.destroy();
+        this.#data?.destroy();
+    }
+}
+exports.default = Decoder;

package/opus/Encoder.d.ts

@@ -0,0 +1,23 @@
+import { Runtime } from "../runtime";
+export default class Encoder {
+    #private;
+    constructor(runtime: Runtime, sampleRate: number, channels: number, application: number, 
+    /**
+     * what is the size of the buffer that holds the encoded data
+     */
+    outBufferLength: number, 
+    /**
+     * how many bytes will we be receiving through encodeFloat() function
+     */
+    pcmBufferLength: number);
+    encoded(): Uint8Array;
+    /**
+     *
+     * @param value
+     * @param frameSize
+     * @param maxDataBytes
+     * @returns encoded sample count
+     */
+    encodeFloat(value: Float32Array, frameSize: number, maxDataBytes: number): number;
+    destroy(): void;
+}

package/opus/Encoder.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../runtime");
+class Encoder {
+    #errorPointer;
+    #error;
+    #runtime;
+    #encoder;
+    #encoded;
+    #pcm;
+    #holder;
+    constructor(runtime, sampleRate, channels, application, 
+    /**
+     * what is the size of the buffer that holds the encoded data
+     */
+    outBufferLength, 
+    /**
+     * how many bytes will we be receiving through encodeFloat() function
+     */
+    pcmBufferLength) {
+        if (!outBufferLength) {
+            throw new Error("outBufferLength must be more than 0");
+        }
+        this.#holder = new runtime_1.ResourcesHolder();
+        this.#error = new runtime_1.Integer(runtime);
+        this.#runtime = runtime;
+        this.#errorPointer = new runtime_1.Pointer(runtime, this.#error);
+        /**
+         * pcm buffer
+         */
+        this.#pcm = new runtime_1.Buffer(runtime, pcmBufferLength);
+        /**
+         * out buffer
+         */
+        this.#encoded = new runtime_1.Buffer(runtime, outBufferLength);
+        /**
+         * add items to resources holder
+         */
+        this.#holder.add(this.#encoded);
+        this.#holder.add(this.#pcm);
+        this.#holder.add(this.#errorPointer);
+        this.#holder.add(this.#error);
+        /**
+         * create encoder
+         */
+        this.#encoder = runtime
+            .originalRuntime()
+            ._opus_encoder_create(sampleRate, channels, application, this.#errorPointer.value());
+        if (this.#error.value() < 0) {
+            throw new Error("Failed to create encoder");
+        }
+    }
+    encoded() {
+        return this.#encoded.data();
+    }
+    /**
+     *
+     * @param value
+     * @param frameSize
+     * @param maxDataBytes
+     * @returns encoded sample count
+     */
+    encodeFloat(value, frameSize, maxDataBytes) {
+        if (maxDataBytes > this.#encoded.size()) {
+            throw new Error(`encoded buffer length is ${this.#encoded.size()}, but maxDataBytes is ${maxDataBytes}`);
+        }
+        this.#pcm
+            .data()
+            .set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+        const result = this.#runtime
+            .originalRuntime()
+            ._opus_encode_float(this.#encoder, this.#pcm.offset(), frameSize, this.#encoded.offset(), maxDataBytes);
+        if (result < 0) {
+            throw new Error(`Failed to encode float`);
+        }
+        return result;
+    }
+    destroy() {
+        this.#holder.destroy();
+        this.#runtime.originalRuntime()._opus_encoder_destroy(this.#encoder);
+    }
+}
+exports.default = Encoder;

package/opus/RingBuffer.d.ts

@@ -0,0 +1,6 @@
+export default class RingBuffer {
+    #private;
+    constructor(frameSize: number);
+    write(value: Float32Array): void;
+    read(): Float32Array | null;
+}

package/opus/RingBuffer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RingBuffer {
+    #arrayBuffer;
+    #readOffset;
+    #writeOffset;
+    #frameSize;
+    constructor(frameSize) {
+        this.#readOffset = 0;
+        this.#writeOffset = 0;
+        this.#arrayBuffer = new ArrayBuffer(1024 * 1024 * 4);
+        this.#frameSize = frameSize;
+    }
+    #view() {
+        return new Float32Array(this.#arrayBuffer);
+    }
+    write(value) {
+        this.#maybeReallocate(value.length);
+        this.#view().set(value, this.#writeOffset);
+        this.#writeOffset += value.length;
+    }
+    read() {
+        if (this.#writeOffset >= this.#frameSize) {
+            const view = this.#view().subarray(this.#readOffset, this.#readOffset + this.#frameSize);
+            this.#readOffset += this.#frameSize;
+            if (this.#readOffset >= this.#writeOffset) {
+                this.#writeOffset = 0;
+            }
+            return view;
+        }
+        return null;
+    }
+    #maybeReallocate(samples) {
+        const sampleCountInBytes = samples * Float32Array.BYTES_PER_ELEMENT;
+        if (this.#view().length <= samples) {
+            const oldArrayBuffer = this.#arrayBuffer;
+            this.#arrayBuffer = new ArrayBuffer(oldArrayBuffer.byteLength + sampleCountInBytes + 1024 * 1024 * 4);
+            this.#view().set(new Uint8Array(oldArrayBuffer));
+        }
+    }
+}
+exports.default = RingBuffer;

package/opus/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Encoder } from './Encoder';
+export { default as Decoder } from './Decoder';
+export { default as RingBuffer } from './RingBuffer';

package/opus/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingBuffer = exports.Decoder = exports.Encoder = void 0;
+var Encoder_1 = require("./Encoder");
+Object.defineProperty(exports, "Encoder", { enumerable: true, get: function () { return __importDefault(Encoder_1).default; } });
+var Decoder_1 = require("./Decoder");
+Object.defineProperty(exports, "Decoder", { enumerable: true, get: function () { return __importDefault(Decoder_1).default; } });
+var RingBuffer_1 = require("./RingBuffer");
+Object.defineProperty(exports, "RingBuffer", { enumerable: true, get: function () { return __importDefault(RingBuffer_1).default; } });

package/package.json

@@ -0,0 +1,21 @@
+{
+    "devDependencies": {
+        "@types/node": "14.x",
+        "prettier": "2.x",
+        "ts-loader": "9.x",
+        "ts-node": "10.x",
+        "typescript": "5.x",
+        "webpack": "5.x",
+        "webpack-cli": "5.x"
+    },
+    "name": "opus-codec",
+    "version": "0.0.1",
+    "license": "MIT",
+    "files": [
+        "{native,runtime,opus}/*.{d.ts,js,wasm}"
+    ],
+    "scripts": {
+        "prepublishOnly": "npx tsc -b opus runtime",
+        "test": "npx ts-node test"
+    }
+}

package/runtime/Buffer.d.ts

@@ -0,0 +1,10 @@
+import { IResource } from "./ResourcesHolder";
+import Runtime from "./Runtime";
+export default class Buffer implements IResource {
+    #private;
+    constructor(runtime: Runtime, size: number);
+    offset(): number;
+    data(): Uint8Array;
+    size(): number;
+    destroy(): void;
+}

package/runtime/Buffer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Buffer {
+    #offset;
+    #size;
+    #runtime;
+    constructor(runtime, size) {
+        this.#runtime = runtime;
+        this.#size = size;
+        this.#offset = runtime.malloc(size);
+    }
+    offset() {
+        return this.#offset;
+    }
+    data() {
+        return this.#runtime.subarray(this.#offset, this.#offset + this.#size);
+    }
+    size() {
+        return this.#size;
+    }
+    destroy() {
+        this.#runtime.free(this.#offset);
+        this.#offset = 0;
+    }
+}
+exports.default = Buffer;

package/runtime/Integer.d.ts

@@ -0,0 +1,10 @@
+import { IResource } from "./ResourcesHolder";
+import Runtime from "./Runtime";
+export default class Integer implements IResource {
+    #private;
+    constructor(runtime: Runtime);
+    value(): number;
+    size(): number;
+    offset(): number;
+    destroy(): void;
+}

package/runtime/Integer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Integer {
+    #runtime;
+    #offset;
+    constructor(runtime) {
+        this.#runtime = runtime;
+        this.#offset = runtime.malloc(runtime.originalRuntime()._size_of_int());
+    }
+    value() {
+        if (this.#runtime.originalRuntime()._size_of_int() !== 4) {
+            throw new Error('invalid integer byte size');
+        }
+        return this.#runtime.view().getInt32(this.#offset);
+    }
+    size() {
+        return this.#runtime.originalRuntime()._size_of_int();
+    }
+    offset() {
+        return this.#offset;
+    }
+    destroy() {
+        this.#runtime.free(this.#offset);
+        this.#offset = 0;
+    }
+}
+exports.default = Integer;

package/runtime/Pointer.d.ts

@@ -0,0 +1,10 @@
+import Integer from "./Integer";
+import { IResource } from "./ResourcesHolder";
+import Runtime from "./Runtime";
+export default class Pointer implements IResource {
+    #private;
+    constructor(runtime: Runtime, value: Integer);
+    offset(): number;
+    destroy(): void;
+    value(): number;
+}

package/runtime/Pointer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Pointer {
+    #offset;
+    #runtime;
+    constructor(runtime, value) {
+        this.#runtime = runtime;
+        this.#offset = runtime.malloc(runtime.originalRuntime()._size_of_void_ptr());
+        this.#runtime.view().setUint32(this.#offset, value.offset(), true);
+    }
+    offset() {
+        return this.#offset;
+    }
+    destroy() {
+        this.#runtime.free(this.#offset);
+    }
+    value() {
+        return this.#runtime.view().getUint32(this.#offset, true);
+    }
+}
+exports.default = Pointer;

package/runtime/ResourcesHolder.d.ts

@@ -0,0 +1,9 @@
+export default class ResourcesHolder {
+    #private;
+    constructor();
+    add(resource: IResource): void;
+    destroy(): void;
+}
+export interface IResource {
+    destroy(): void;
+}

package/runtime/ResourcesHolder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ResourcesHolder {
+    #resources = new Set();
+    constructor() {
+    }
+    add(resource) {
+        this.#resources.add(resource);
+    }
+    destroy() {
+        for (const r of this.#resources) {
+            r.destroy();
+        }
+    }
+}
+exports.default = ResourcesHolder;

package/runtime/Runtime.d.ts

@@ -0,0 +1,10 @@
+import { EmscriptenRuntime } from "../native";
+export default class Runtime {
+    #private;
+    constructor(runtime: EmscriptenRuntime);
+    originalRuntime(): EmscriptenRuntime;
+    subarray(start: number, end: number): Uint8Array;
+    free(offset: number): void;
+    view(): DataView;
+    malloc(len: number): number;
+}

package/runtime/Runtime.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Runtime {
+    #runtime;
+    constructor(runtime) {
+        this.#runtime = runtime;
+    }
+    originalRuntime() {
+        return this.#runtime;
+    }
+    subarray(start, end) {
+        return this.#runtime.HEAPU8.subarray(start, end);
+    }
+    free(offset) {
+        this.#runtime._free(offset);
+    }
+    view() {
+        return new DataView(this.#runtime.HEAPU8.buffer);
+    }
+    malloc(len) {
+        const offset = this.#runtime._malloc(len);
+        if (!offset) {
+            throw new Error(`failed to allocate ${len} bytes`);
+        }
+        return offset;
+    }
+}
+exports.default = Runtime;

package/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Integer } from './Integer';
+export { default as Pointer } from './Pointer';
+export { default as Runtime } from './Runtime';
+export { default as Buffer } from './Buffer';
+export { default as ResourcesHolder, IResource } from './ResourcesHolder';

package/runtime/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcesHolder = exports.Buffer = exports.Runtime = exports.Pointer = exports.Integer = void 0;
+var Integer_1 = require("./Integer");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return __importDefault(Integer_1).default; } });
+var Pointer_1 = require("./Pointer");
+Object.defineProperty(exports, "Pointer", { enumerable: true, get: function () { return __importDefault(Pointer_1).default; } });
+var Runtime_1 = require("./Runtime");
+Object.defineProperty(exports, "Runtime", { enumerable: true, get: function () { return __importDefault(Runtime_1).default; } });
+var Buffer_1 = require("./Buffer");
+Object.defineProperty(exports, "Buffer", { enumerable: true, get: function () { return __importDefault(Buffer_1).default; } });
+var ResourcesHolder_1 = require("./ResourcesHolder");
+Object.defineProperty(exports, "ResourcesHolder", { enumerable: true, get: function () { return __importDefault(ResourcesHolder_1).default; } });