opus-codec 0.0.69 → 0.0.71

package/es/actions/opus.js

@@ -0,0 +1,293 @@
+export var OpusRequest;
+(function (OpusRequest) {
+    OpusRequest["SetComplexity"] = "OPUS_SET_COMPLEXITY";
+    OpusRequest["GetComplexity"] = "OPUS_GET_COMPLEXITY";
+    OpusRequest["SetBitrate"] = "OPUS_SET_BITRATE";
+    OpusRequest["GetBitrate"] = "OPUS_GET_BITRATE";
+    OpusRequest["SetVbr"] = "OPUS_SET_VBR";
+    OpusRequest["GetVbr"] = "OPUS_GET_VBR";
+    OpusRequest["SetVbrConstraint"] = "OPUS_SET_VBR_CONSTRAINT";
+    OpusRequest["GetVbrConstraint"] = "OPUS_GET_VBR_CONSTRAINT";
+    OpusRequest["SetForceChannels"] = "OPUS_SET_FORCE_CHANNELS";
+    OpusRequest["GetForceChannels"] = "OPUS_GET_FORCE_CHANNELS";
+    OpusRequest["SetMaxBandwidth"] = "OPUS_SET_MAX_BANDWIDTH";
+    OpusRequest["GetMaxBandwidth"] = "OPUS_GET_MAX_BANDWIDTH";
+    OpusRequest["SetBandwidth"] = "OPUS_SET_BANDWIDTH";
+    OpusRequest["SetSignal"] = "OPUS_SET_SIGNAL";
+    OpusRequest["GetSignal"] = "OPUS_GET_SIGNAL";
+    OpusRequest["SetApplication"] = "OPUS_SET_APPLICATION";
+    OpusRequest["GetApplication"] = "OPUS_GET_APPLICATION";
+    OpusRequest["GetLookahead"] = "OPUS_GET_LOOKAHEAD";
+    OpusRequest["SetInbandFec"] = "OPUS_SET_INBAND_FEC";
+    OpusRequest["GetInbandFec"] = "OPUS_GET_INBAND_FEC";
+    OpusRequest["SetPacketLossperc"] = "OPUS_SET_PACKET_LOSS_PERC";
+    OpusRequest["GetPacketLossperc"] = "OPUS_GET_PACKET_LOSS_PERC";
+    OpusRequest["SetDtx"] = "OPUS_SET_DTX";
+    OpusRequest["GetDtx"] = "OPUS_GET_DTX";
+    OpusRequest["SetLsbDepth"] = "OPUS_SET_LSB_DEPTH";
+    OpusRequest["GetLsbDepth"] = "OPUS_GET_LSB_DEPTH";
+    OpusRequest["SetExpertFrameduration"] = "OPUS_SET_EXPERT_FRAME_DURATION";
+    OpusRequest["GetExpertFrameduration"] = "OPUS_GET_EXPERT_FRAME_DURATION";
+    OpusRequest["SetPredictionDisabled"] = "OPUS_SET_PREDICTION_DISABLED";
+    OpusRequest["GetPredictionDisabled"] = "OPUS_GET_PREDICTION_DISABLED";
+    OpusRequest["GetBandwidth"] = "OPUS_GET_BANDWIDTH";
+    OpusRequest["GetSampleRate"] = "OPUS_GET_SAMPLE_RATE";
+    OpusRequest["SetPhaseInversiondisabled"] = "OPUS_SET_PHASE_INVERSION_DISABLED";
+    OpusRequest["GetPhaseInversiondisabled"] = "OPUS_GET_PHASE_INVERSION_DISABLED";
+    OpusRequest["GetInDtx"] = "OPUS_GET_IN_DTX";
+    OpusRequest["SetGain"] = "OPUS_SET_GAIN";
+    OpusRequest["GetGain"] = "OPUS_GET_GAIN";
+    OpusRequest["GetLastPacketduration"] = "OPUS_GET_LAST_PACKET_DURATION";
+    OpusRequest["GetPitch"] = "OPUS_GET_PITCH";
+})(OpusRequest || (OpusRequest = {}));
+export function OPUS_SET_COMPLEXITY(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetComplexity,
+        value: x
+    };
+}
+export function OPUS_GET_COMPLEXITY(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetComplexity,
+    };
+}
+export function OPUS_SET_BITRATE(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetBitrate,
+        value: x
+    };
+}
+export function OPUS_GET_BITRATE(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetBitrate,
+    };
+}
+export function OPUS_SET_VBR(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetVbr,
+        value: x
+    };
+}
+export function OPUS_GET_VBR(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetVbr,
+    };
+}
+export function OPUS_SET_VBR_CONSTRAINT(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetVbrConstraint,
+        value: x
+    };
+}
+export function OPUS_GET_VBR_CONSTRAINT(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetVbrConstraint,
+    };
+}
+export function OPUS_SET_FORCE_CHANNELS(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetForceChannels,
+        value: x
+    };
+}
+export function OPUS_GET_FORCE_CHANNELS(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetForceChannels,
+    };
+}
+export function OPUS_SET_MAX_BANDWIDTH(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetMaxBandwidth,
+        value: x
+    };
+}
+export function OPUS_GET_MAX_BANDWIDTH(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetMaxBandwidth,
+    };
+}
+export function OPUS_SET_BANDWIDTH(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetBandwidth,
+        value: x
+    };
+}
+export function OPUS_SET_SIGNAL(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetSignal,
+        value: x
+    };
+}
+export function OPUS_GET_SIGNAL(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetSignal,
+    };
+}
+export function OPUS_SET_APPLICATION(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetApplication,
+        value: x
+    };
+}
+export function OPUS_GET_APPLICATION(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetApplication,
+    };
+}
+export function OPUS_GET_LOOKAHEAD(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetLookahead,
+    };
+}
+export function OPUS_SET_INBAND_FEC(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetInbandFec,
+        value: x
+    };
+}
+export function OPUS_GET_INBAND_FEC(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetInbandFec,
+    };
+}
+export function OPUS_SET_PACKET_LOSS_PERC(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetPacketLossperc,
+        value: x
+    };
+}
+export function OPUS_GET_PACKET_LOSS_PERC(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetPacketLossperc,
+    };
+}
+export function OPUS_SET_DTX(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetDtx,
+        value: x
+    };
+}
+export function OPUS_GET_DTX(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetDtx,
+    };
+}
+export function OPUS_SET_LSB_DEPTH(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetLsbDepth,
+        value: x
+    };
+}
+export function OPUS_GET_LSB_DEPTH(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetLsbDepth,
+    };
+}
+export function OPUS_SET_EXPERT_FRAME_DURATION(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetExpertFrameduration,
+        value: x
+    };
+}
+export function OPUS_GET_EXPERT_FRAME_DURATION(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetExpertFrameduration,
+    };
+}
+export function OPUS_SET_PREDICTION_DISABLED(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetPredictionDisabled,
+        value: x
+    };
+}
+export function OPUS_GET_PREDICTION_DISABLED(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetPredictionDisabled,
+    };
+}
+export function OPUS_GET_BANDWIDTH(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetBandwidth,
+    };
+}
+export function OPUS_GET_SAMPLE_RATE(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetSampleRate,
+    };
+}
+export function OPUS_SET_PHASE_INVERSION_DISABLED(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetPhaseInversiondisabled,
+        value: x
+    };
+}
+export function OPUS_GET_PHASE_INVERSION_DISABLED(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetPhaseInversiondisabled,
+    };
+}
+export function OPUS_GET_IN_DTX(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetInDtx,
+    };
+}
+export function OPUS_SET_GAIN(encoderId, x) {
+    return {
+        encoderId,
+        type: OpusRequest.SetGain,
+        value: x
+    };
+}
+export function OPUS_GET_GAIN(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetGain,
+    };
+}
+export function OPUS_GET_LAST_PACKET_DURATION(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetLastPacketduration,
+    };
+}
+export function OPUS_GET_PITCH(encoderId) {
+    return {
+        encoderId,
+        type: OpusRequest.GetPitch,
+    };
+}

package/es/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/es/opus/Decoder.js

@@ -0,0 +1,72 @@
+import { Integer, ResourcesHolder, Buffer } from '../runtime';
+export default class Decoder {
+    #error;
+    #decoder;
+    #holder;
+    #runtime;
+    #pcm;
+    #frameSize;
+    constructor(runtime, sampleRate, channels, frameSize) {
+        this.#frameSize = frameSize;
+        this.#runtime = runtime;
+        this.#holder = new ResourcesHolder();
+        this.#error = new Integer(runtime);
+        /**
+         * holder
+         */
+        this.#holder.add(this.#error);
+        /**
+         * create decoder
+         */
+        this.#decoder = runtime
+            .originalRuntime()
+            ._opus_decoder_create(sampleRate, channels, this.#error.offset());
+        if (!this.#decoder || this.#error.value() < 0) {
+            throw new Error('Failed to create decoder');
+        }
+        this.#pcm = new Buffer(runtime, this.#frameSize * channels * Float32Array.BYTES_PER_ELEMENT);
+    }
+    #data = null;
+    decodeFloat(value, decodeFec = 0) {
+        let data = this.#data;
+        if (!data) {
+            data = new 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 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();
+    }
+}

package/es/opus/Encoder.d.ts

@@ -0,0 +1,24 @@
+import { Runtime } from '../runtime';
+import { OpusGettersAndSetters } from './OpusGettersAndSetters';
+export default class Encoder extends OpusGettersAndSetters {
+    #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/es/opus/Encoder.js

@@ -0,0 +1,81 @@
+import { Integer, ResourcesHolder, Buffer } from '../runtime';
+import { OpusGettersAndSetters } from './OpusGettersAndSetters';
+export default class Encoder extends OpusGettersAndSetters {
+    #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) {
+        const error = new Integer(runtime);
+        const encoderId = runtime
+            .originalRuntime()
+            ._opus_encoder_create(sampleRate, channels, application, error.offset());
+        super(runtime, encoderId);
+        this.#holder = new ResourcesHolder();
+        this.#error = error;
+        this.#runtime = runtime;
+        /**
+         * pcm buffer
+         */
+        this.#pcm = new Buffer(runtime, pcmBufferLength);
+        /**
+         * out buffer
+         */
+        this.#encoded = new Buffer(runtime, outBufferLength);
+        /**
+         * add items to resources holder
+         */
+        this.#holder.add(this.#encoded);
+        this.#holder.add(this.#pcm);
+        this.#holder.add(this.#error);
+        /**
+         * create encoder
+         */
+        this.#encoder = encoderId;
+        if (error.value() < 0) {
+            throw new Error('Failed to create encoder');
+        }
+        if (!outBufferLength) {
+            throw new Error('outBufferLength must be more than 0');
+        }
+    }
+    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);
+    }
+}

package/es/opus/OpusGettersAndSetters.d.ts

@@ -0,0 +1,44 @@
+import { Runtime } from '../runtime';
+export declare class OpusGettersAndSetters {
+    #private;
+    constructor(runtime: Runtime, opusEncoderOffset: number);
+    setComplexity(x: number): boolean;
+    getComplexity(): number;
+    setBitrate(x: number): boolean;
+    getBitrate(): number;
+    setVbr(x: number): boolean;
+    getVbr(): number;
+    setVbrConstraint(x: number): boolean;
+    getVbrConstraint(): number;
+    setForceChannels(x: number): boolean;
+    getForceChannels(): number;
+    setMaxBandwidth(x: number): boolean;
+    getMaxBandwidth(): number;
+    setBandwidth(x: number): boolean;
+    setSignal(x: number): boolean;
+    getSignal(): number;
+    setApplication(x: number): boolean;
+    getApplication(): number;
+    getLookahead(): number;
+    setInbandFec(x: number): boolean;
+    getInbandFec(): number;
+    setPacketLossperc(x: number): boolean;
+    getPacketLossperc(): number;
+    setDtx(x: number): boolean;
+    getDtx(): number;
+    setLsbDepth(x: number): boolean;
+    getLsbDepth(): number;
+    setExpertFrameduration(x: number): boolean;
+    getExpertFrameduration(): number;
+    setPredictionDisabled(x: number): boolean;
+    getPredictionDisabled(): number;
+    getBandwidth(): number;
+    getSampleRate(): number;
+    setPhaseInversiondisabled(x: number): boolean;
+    getPhaseInversiondisabled(): number;
+    getInDtx(): number;
+    setGain(x: number): boolean;
+    getGain(): number;
+    getLastPacketduration(): number;
+    getPitch(): number;
+}