opus-codec 0.0.68 → 0.0.70

package/es/actions/Client.d.ts

@@ -0,0 +1,10 @@
+import { IWorkerRequest, RequestResponse, RequestResponseType } from './actions';
+export default class Client {
+    #private;
+    constructor(worker: Worker);
+    close(): void;
+    sendMessage<T extends IWorkerRequest<unknown, unknown>>(data: T): Promise<RequestResponse<RequestResponseType<T>>>;
+    private onMessageError;
+    private onError;
+    private onMessage;
+}

package/es/actions/Client.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { boundMethod } from 'autobind-decorator';
+export default class Client {
+    #worker;
+    #pending = new Map();
+    constructor(worker) {
+        this.#worker = worker;
+        worker.addEventListener('message', this.onMessage);
+        worker.addEventListener('messageerror', this.onMessageError);
+        worker.addEventListener('error', this.onError);
+    }
+    close() {
+        this.#worker.terminate();
+        for (const p of this.#pending) {
+            this.#pending.delete(p[0]);
+            p[1]({
+                requestId: p[0],
+                failures: ['Worker destroyed'],
+            });
+        }
+    }
+    sendMessage(data) {
+        const waitTimeBeforeResolvingAutomaticallyInMilliseconds = 10000;
+        return new Promise((resolve, reject) => {
+            if (this.#pending.has(data.requestId)) {
+                reject(new Error(`Request already exists: ${data.requestId}`));
+                return;
+            }
+            const timeoutId = setTimeout(() => {
+                resolve({
+                    requestId: data.requestId,
+                    failures: [
+                        `Timeout expired. It took more than ${waitTimeBeforeResolvingAutomaticallyInMilliseconds} to resolve this request.`,
+                    ],
+                });
+            }, waitTimeBeforeResolvingAutomaticallyInMilliseconds);
+            this.#pending.set(data.requestId, (data) => {
+                clearTimeout(timeoutId);
+                resolve(data);
+            });
+            this.#worker.postMessage(data);
+        });
+    }
+    onMessageError(e) {
+        console.error(e);
+    }
+    onError(e) {
+        console.error(e);
+    }
+    onMessage(e) {
+        const data = e.data;
+        const request = this.#pending.get(data.requestId);
+        if (!request) {
+            console.error('failed to get pending request: %s', data.requestId);
+            return;
+        }
+        request(data);
+    }
+}
+__decorate([
+    boundMethod
+], Client.prototype, "onMessageError", null);
+__decorate([
+    boundMethod
+], Client.prototype, "onError", null);
+__decorate([
+    boundMethod
+], Client.prototype, "onMessage", null);

package/es/actions/actions.d.ts

@@ -0,0 +1,112 @@
+import { OpusGetRequest, OpusSetRequest } from './opus';
+export interface IWorkerRequest<Data, Response> {
+    data: Data;
+    _response?: RequestResponse<Response>;
+    transfer?: ArrayBuffer[];
+    requestId: RequestId;
+}
+export type CodecId = string;
+export type RequestResponse<T> = {
+    requestId: RequestId;
+    value: T;
+} | {
+    requestId: RequestId;
+    failures: string[];
+};
+export type RequestId = ReturnType<typeof getRequestId>;
+export interface ICreateEncoderOptions {
+    sampleRate: number;
+    channels: number;
+    application: number;
+    outBufferLength: number;
+    pcmBufferLength: number;
+}
+export interface IOpusGetRequest extends IWorkerRequest<OpusGetRequest, number> {
+    type: RequestType.OpusGetRequest;
+}
+export declare function getFromEncoder(data: OpusGetRequest): IOpusGetRequest;
+export interface IOpusSetRequest extends IWorkerRequest<OpusSetRequest, boolean> {
+    type: RequestType.OpusSetRequest;
+}
+export declare function setToEncoder(data: OpusSetRequest): IOpusSetRequest;
+export interface ICreateEncoder extends IWorkerRequest<ICreateEncoderOptions, CodecId> {
+    type: RequestType.CreateEncoder;
+}
+export interface ICreateDecoderOptions {
+    sampleRate: number;
+    channels: number;
+    frameSize: number;
+}
+export interface ICreateDecoder extends IWorkerRequest<ICreateDecoderOptions, CodecId> {
+    type: RequestType.CreateDecoder;
+}
+export declare function createDecoder(sampleRate: number, channels: number, frameSize: number): ICreateDecoder;
+export interface IDestroyEncoderOptions {
+    encoderId: CodecId;
+}
+export interface IDestroyEncoder extends IWorkerRequest<CodecId, null> {
+    type: RequestType.DestroyEncoder;
+}
+export declare function destroyEncoder(encoderId: CodecId): IDestroyEncoder;
+export interface IDrainRingBufferResult {
+}
+export declare enum RequestType {
+    CreateEncoder = 0,
+    CreateDecoder = 1,
+    EncodeFloat = 2,
+    DecodeFloat = 3,
+    DestroyEncoder = 4,
+    DestroyDecoder = 5,
+    OpusGetRequest = 6,
+    OpusSetRequest = 7
+}
+export interface IDestroyDecoder extends IWorkerRequest<{
+    decoderId: CodecId;
+}, null> {
+    type: RequestType.DestroyDecoder;
+}
+export declare function destroyDecoder(decoderId: CodecId): IDestroyDecoder;
+export interface IDecodeFloatOptions {
+    decoderId: CodecId;
+    decodeFec?: number;
+    encoded: ArrayBuffer;
+}
+export interface IDecodeFloatResult {
+    decoded: ArrayBuffer;
+}
+export interface IDecodeFloat extends IWorkerRequest<IDecodeFloatOptions, IDecodeFloatResult> {
+    type: RequestType.DecodeFloat;
+}
+export declare function decodeFloat(data: IDecodeFloatOptions): IDecodeFloat;
+export interface IEncodeFloatResult {
+    /**
+     * if null, it means the data was written to the ring buffer, but not yet submitted
+     */
+    encoded: {
+        buffer: ArrayBuffer;
+        /**
+         * duration in milliseconds
+         */
+        duration: number;
+    } | null;
+}
+export interface IEncodeFloat extends IWorkerRequest<IEncodeFloatOptions, IEncodeFloatResult> {
+    type: RequestType.EncodeFloat;
+}
+export interface IEncodeFloatOptions {
+    encoderId: CodecId;
+    maxDataBytes: number;
+    /**
+     * if null, it will try to drain the ring buffer for the data
+     * that has been queued
+     */
+    input: {
+        pcm: Float32Array;
+    } | null;
+}
+export type RequestResponseType<T> = T extends IWorkerRequest<unknown, infer R> ? R : never;
+export type WorkerRequest = IEncodeFloat | ICreateEncoder | ICreateDecoder | IDestroyDecoder | IDecodeFloat | IDestroyEncoder | IOpusGetRequest | IOpusSetRequest;
+declare function getRequestId(): string;
+export declare function createEncoder(data: ICreateEncoderOptions): ICreateEncoder;
+export declare function encodeFloat(data: IEncodeFloatOptions): IEncodeFloat;
+export {};

package/es/actions/actions.js

@@ -0,0 +1,79 @@
+export function getFromEncoder(data) {
+    return {
+        type: RequestType.OpusGetRequest,
+        data,
+        requestId: getRequestId(),
+    };
+}
+export function setToEncoder(data) {
+    return {
+        type: RequestType.OpusSetRequest,
+        data,
+        requestId: getRequestId(),
+    };
+}
+export function createDecoder(sampleRate, channels, frameSize) {
+    return {
+        type: RequestType.CreateDecoder,
+        data: {
+            frameSize,
+            sampleRate,
+            channels,
+        },
+        requestId: getRequestId(),
+    };
+}
+export function destroyEncoder(encoderId) {
+    return {
+        type: RequestType.DestroyEncoder,
+        data: encoderId,
+        requestId: getRequestId(),
+    };
+}
+export var RequestType;
+(function (RequestType) {
+    RequestType[RequestType["CreateEncoder"] = 0] = "CreateEncoder";
+    RequestType[RequestType["CreateDecoder"] = 1] = "CreateDecoder";
+    RequestType[RequestType["EncodeFloat"] = 2] = "EncodeFloat";
+    RequestType[RequestType["DecodeFloat"] = 3] = "DecodeFloat";
+    RequestType[RequestType["DestroyEncoder"] = 4] = "DestroyEncoder";
+    RequestType[RequestType["DestroyDecoder"] = 5] = "DestroyDecoder";
+    RequestType[RequestType["OpusGetRequest"] = 6] = "OpusGetRequest";
+    RequestType[RequestType["OpusSetRequest"] = 7] = "OpusSetRequest";
+})(RequestType || (RequestType = {}));
+export function destroyDecoder(decoderId) {
+    return {
+        type: RequestType.DestroyDecoder,
+        data: {
+            decoderId,
+        },
+        requestId: getRequestId(),
+    };
+}
+export function decodeFloat(data) {
+    return {
+        type: RequestType.DecodeFloat,
+        data,
+        requestId: getRequestId(),
+        transfer: [data.encoded],
+    };
+}
+function getRequestId() {
+    const ids = crypto.getRandomValues(new Int32Array(4));
+    return ids.join('-');
+}
+export function createEncoder(data) {
+    return {
+        data,
+        requestId: getRequestId(),
+        type: RequestType.CreateEncoder,
+    };
+}
+export function encodeFloat(data) {
+    return {
+        data,
+        requestId: getRequestId(),
+        type: RequestType.EncodeFloat,
+        transfer: data.input !== null ? [data.input.pcm] : [],
+    };
+}

package/es/actions/index.d.ts

@@ -0,0 +1 @@
+export * as default from './actions';

package/es/actions/index.js

@@ -0,0 +1 @@
+export * as default from './actions';

package/es/actions/opus.d.ts

@@ -0,0 +1,255 @@
+export declare enum OpusRequest {
+    SetComplexity = "OPUS_SET_COMPLEXITY",
+    GetComplexity = "OPUS_GET_COMPLEXITY",
+    SetBitrate = "OPUS_SET_BITRATE",
+    GetBitrate = "OPUS_GET_BITRATE",
+    SetVbr = "OPUS_SET_VBR",
+    GetVbr = "OPUS_GET_VBR",
+    SetVbrConstraint = "OPUS_SET_VBR_CONSTRAINT",
+    GetVbrConstraint = "OPUS_GET_VBR_CONSTRAINT",
+    SetForceChannels = "OPUS_SET_FORCE_CHANNELS",
+    GetForceChannels = "OPUS_GET_FORCE_CHANNELS",
+    SetMaxBandwidth = "OPUS_SET_MAX_BANDWIDTH",
+    GetMaxBandwidth = "OPUS_GET_MAX_BANDWIDTH",
+    SetBandwidth = "OPUS_SET_BANDWIDTH",
+    SetSignal = "OPUS_SET_SIGNAL",
+    GetSignal = "OPUS_GET_SIGNAL",
+    SetApplication = "OPUS_SET_APPLICATION",
+    GetApplication = "OPUS_GET_APPLICATION",
+    GetLookahead = "OPUS_GET_LOOKAHEAD",
+    SetInbandFec = "OPUS_SET_INBAND_FEC",
+    GetInbandFec = "OPUS_GET_INBAND_FEC",
+    SetPacketLossperc = "OPUS_SET_PACKET_LOSS_PERC",
+    GetPacketLossperc = "OPUS_GET_PACKET_LOSS_PERC",
+    SetDtx = "OPUS_SET_DTX",
+    GetDtx = "OPUS_GET_DTX",
+    SetLsbDepth = "OPUS_SET_LSB_DEPTH",
+    GetLsbDepth = "OPUS_GET_LSB_DEPTH",
+    SetExpertFrameduration = "OPUS_SET_EXPERT_FRAME_DURATION",
+    GetExpertFrameduration = "OPUS_GET_EXPERT_FRAME_DURATION",
+    SetPredictionDisabled = "OPUS_SET_PREDICTION_DISABLED",
+    GetPredictionDisabled = "OPUS_GET_PREDICTION_DISABLED",
+    GetBandwidth = "OPUS_GET_BANDWIDTH",
+    GetSampleRate = "OPUS_GET_SAMPLE_RATE",
+    SetPhaseInversiondisabled = "OPUS_SET_PHASE_INVERSION_DISABLED",
+    GetPhaseInversiondisabled = "OPUS_GET_PHASE_INVERSION_DISABLED",
+    GetInDtx = "OPUS_GET_IN_DTX",
+    SetGain = "OPUS_SET_GAIN",
+    GetGain = "OPUS_GET_GAIN",
+    GetLastPacketduration = "OPUS_GET_LAST_PACKET_DURATION",
+    GetPitch = "OPUS_GET_PITCH"
+}
+export interface IOpusSetComplexity {
+    type: OpusRequest.SetComplexity;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_COMPLEXITY(encoderId: string, x: number): IOpusSetComplexity;
+export interface IOpusGetComplexity {
+    type: OpusRequest.GetComplexity;
+    encoderId: string;
+}
+export declare function OPUS_GET_COMPLEXITY(encoderId: string): IOpusGetComplexity;
+export interface IOpusSetBitrate {
+    type: OpusRequest.SetBitrate;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_BITRATE(encoderId: string, x: number): IOpusSetBitrate;
+export interface IOpusGetBitrate {
+    type: OpusRequest.GetBitrate;
+    encoderId: string;
+}
+export declare function OPUS_GET_BITRATE(encoderId: string): IOpusGetBitrate;
+export interface IOpusSetVbr {
+    type: OpusRequest.SetVbr;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_VBR(encoderId: string, x: number): IOpusSetVbr;
+export interface IOpusGetVbr {
+    type: OpusRequest.GetVbr;
+    encoderId: string;
+}
+export declare function OPUS_GET_VBR(encoderId: string): IOpusGetVbr;
+export interface IOpusSetVbrconstraint {
+    type: OpusRequest.SetVbrConstraint;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_VBR_CONSTRAINT(encoderId: string, x: number): IOpusSetVbrconstraint;
+export interface IOpusGetVbrconstraint {
+    type: OpusRequest.GetVbrConstraint;
+    encoderId: string;
+}
+export declare function OPUS_GET_VBR_CONSTRAINT(encoderId: string): IOpusGetVbrconstraint;
+export interface IOpusSetForcechannels {
+    type: OpusRequest.SetForceChannels;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_FORCE_CHANNELS(encoderId: string, x: number): IOpusSetForcechannels;
+export interface IOpusGetForcechannels {
+    type: OpusRequest.GetForceChannels;
+    encoderId: string;
+}
+export declare function OPUS_GET_FORCE_CHANNELS(encoderId: string): IOpusGetForcechannels;
+export interface IOpusSetMaxbandwidth {
+    type: OpusRequest.SetMaxBandwidth;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_MAX_BANDWIDTH(encoderId: string, x: number): IOpusSetMaxbandwidth;
+export interface IOpusGetMaxbandwidth {
+    type: OpusRequest.GetMaxBandwidth;
+    encoderId: string;
+}
+export declare function OPUS_GET_MAX_BANDWIDTH(encoderId: string): IOpusGetMaxbandwidth;
+export interface IOpusSetBandwidth {
+    type: OpusRequest.SetBandwidth;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_BANDWIDTH(encoderId: string, x: number): IOpusSetBandwidth;
+export interface IOpusSetSignal {
+    type: OpusRequest.SetSignal;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_SIGNAL(encoderId: string, x: number): IOpusSetSignal;
+export interface IOpusGetSignal {
+    type: OpusRequest.GetSignal;
+    encoderId: string;
+}
+export declare function OPUS_GET_SIGNAL(encoderId: string): IOpusGetSignal;
+export interface IOpusSetApplication {
+    type: OpusRequest.SetApplication;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_APPLICATION(encoderId: string, x: number): IOpusSetApplication;
+export interface IOpusGetApplication {
+    type: OpusRequest.GetApplication;
+    encoderId: string;
+}
+export declare function OPUS_GET_APPLICATION(encoderId: string): IOpusGetApplication;
+export interface IOpusGetLookahead {
+    type: OpusRequest.GetLookahead;
+    encoderId: string;
+}
+export declare function OPUS_GET_LOOKAHEAD(encoderId: string): IOpusGetLookahead;
+export interface IOpusSetInbandfec {
+    type: OpusRequest.SetInbandFec;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_INBAND_FEC(encoderId: string, x: number): IOpusSetInbandfec;
+export interface IOpusGetInbandfec {
+    type: OpusRequest.GetInbandFec;
+    encoderId: string;
+}
+export declare function OPUS_GET_INBAND_FEC(encoderId: string): IOpusGetInbandfec;
+export interface IOpusSetPacketlossPerc {
+    type: OpusRequest.SetPacketLossperc;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_PACKET_LOSS_PERC(encoderId: string, x: number): IOpusSetPacketlossPerc;
+export interface IOpusGetPacketlossPerc {
+    type: OpusRequest.GetPacketLossperc;
+    encoderId: string;
+}
+export declare function OPUS_GET_PACKET_LOSS_PERC(encoderId: string): IOpusGetPacketlossPerc;
+export interface IOpusSetDtx {
+    type: OpusRequest.SetDtx;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_DTX(encoderId: string, x: number): IOpusSetDtx;
+export interface IOpusGetDtx {
+    type: OpusRequest.GetDtx;
+    encoderId: string;
+}
+export declare function OPUS_GET_DTX(encoderId: string): IOpusGetDtx;
+export interface IOpusSetLsbdepth {
+    type: OpusRequest.SetLsbDepth;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_LSB_DEPTH(encoderId: string, x: number): IOpusSetLsbdepth;
+export interface IOpusGetLsbdepth {
+    type: OpusRequest.GetLsbDepth;
+    encoderId: string;
+}
+export declare function OPUS_GET_LSB_DEPTH(encoderId: string): IOpusGetLsbdepth;
+export interface IOpusSetExpertframeDuration {
+    type: OpusRequest.SetExpertFrameduration;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_EXPERT_FRAME_DURATION(encoderId: string, x: number): IOpusSetExpertframeDuration;
+export interface IOpusGetExpertframeDuration {
+    type: OpusRequest.GetExpertFrameduration;
+    encoderId: string;
+}
+export declare function OPUS_GET_EXPERT_FRAME_DURATION(encoderId: string): IOpusGetExpertframeDuration;
+export interface IOpusSetPredictiondisabled {
+    type: OpusRequest.SetPredictionDisabled;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_PREDICTION_DISABLED(encoderId: string, x: number): IOpusSetPredictiondisabled;
+export interface IOpusGetPredictiondisabled {
+    type: OpusRequest.GetPredictionDisabled;
+    encoderId: string;
+}
+export declare function OPUS_GET_PREDICTION_DISABLED(encoderId: string): IOpusGetPredictiondisabled;
+export interface IOpusGetBandwidth {
+    type: OpusRequest.GetBandwidth;
+    encoderId: string;
+}
+export declare function OPUS_GET_BANDWIDTH(encoderId: string): IOpusGetBandwidth;
+export interface IOpusGetSamplerate {
+    type: OpusRequest.GetSampleRate;
+    encoderId: string;
+}
+export declare function OPUS_GET_SAMPLE_RATE(encoderId: string): IOpusGetSamplerate;
+export interface IOpusSetPhaseinversionDisabled {
+    type: OpusRequest.SetPhaseInversiondisabled;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_PHASE_INVERSION_DISABLED(encoderId: string, x: number): IOpusSetPhaseinversionDisabled;
+export interface IOpusGetPhaseinversionDisabled {
+    type: OpusRequest.GetPhaseInversiondisabled;
+    encoderId: string;
+}
+export declare function OPUS_GET_PHASE_INVERSION_DISABLED(encoderId: string): IOpusGetPhaseinversionDisabled;
+export interface IOpusGetIndtx {
+    type: OpusRequest.GetInDtx;
+    encoderId: string;
+}
+export declare function OPUS_GET_IN_DTX(encoderId: string): IOpusGetIndtx;
+export interface IOpusSetGain {
+    type: OpusRequest.SetGain;
+    encoderId: string;
+    value: number;
+}
+export declare function OPUS_SET_GAIN(encoderId: string, x: number): IOpusSetGain;
+export interface IOpusGetGain {
+    type: OpusRequest.GetGain;
+    encoderId: string;
+}
+export declare function OPUS_GET_GAIN(encoderId: string): IOpusGetGain;
+export interface IOpusGetLastpacketDuration {
+    type: OpusRequest.GetLastPacketduration;
+    encoderId: string;
+}
+export declare function OPUS_GET_LAST_PACKET_DURATION(encoderId: string): IOpusGetLastpacketDuration;
+export interface IOpusGetPitch {
+    type: OpusRequest.GetPitch;
+    encoderId: string;
+}
+export declare function OPUS_GET_PITCH(encoderId: string): IOpusGetPitch;
+export type OpusGetRequest = IOpusGetComplexity | IOpusGetBitrate | IOpusGetVbr | IOpusGetVbrconstraint | IOpusGetForcechannels | IOpusGetMaxbandwidth | IOpusGetSignal | IOpusGetApplication | IOpusGetLookahead | IOpusGetInbandfec | IOpusGetPacketlossPerc | IOpusGetDtx | IOpusGetLsbdepth | IOpusGetExpertframeDuration | IOpusGetPredictiondisabled | IOpusGetBandwidth | IOpusGetSamplerate | IOpusGetPhaseinversionDisabled | IOpusGetIndtx | IOpusGetGain | IOpusGetLastpacketDuration | IOpusGetPitch;
+export type OpusSetRequest = IOpusSetComplexity | IOpusSetBitrate | IOpusSetVbr | IOpusSetVbrconstraint | IOpusSetForcechannels | IOpusSetMaxbandwidth | IOpusSetBandwidth | IOpusSetSignal | IOpusSetApplication | IOpusSetInbandfec | IOpusSetPacketlossPerc | IOpusSetDtx | IOpusSetLsbdepth | IOpusSetExpertframeDuration | IOpusSetPredictiondisabled | IOpusSetPhaseinversionDisabled | IOpusSetGain;