@ikonai/sdk-libopus 0.0.1

package/index.d.ts

@@ -0,0 +1,5 @@
+export { OpusDecoder } from './lib/opus-decoder';
+export { OpusEncoder } from './lib/opus-encoder';
+export { getOpusModule, isModuleLoaded, isSimdSupported } from './lib/opus-module';
+export { OPUS_APPLICATION_VOIP, OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_RESTRICTED_LOWDELAY, OPUS_SET_BITRATE_REQUEST, OPUS_GET_BITRATE_REQUEST, OPUS_SET_COMPLEXITY_REQUEST, OPUS_GET_COMPLEXITY_REQUEST, OPUS_SET_VBR_REQUEST, OPUS_GET_VBR_REQUEST, OPUS_SET_DTX_REQUEST, OPUS_GET_DTX_REQUEST, OPUS_SET_INBAND_FEC_REQUEST, OPUS_GET_INBAND_FEC_REQUEST, OPUS_SET_PACKET_LOSS_PERC_REQUEST, OPUS_GET_PACKET_LOSS_PERC_REQUEST, OPUS_RESET_STATE, OPUS_OK, OPUS_BAD_ARG, OPUS_BUFFER_TOO_SMALL, OPUS_INTERNAL_ERROR, OPUS_INVALID_PACKET, OPUS_UNIMPLEMENTED, OPUS_INVALID_STATE, OPUS_ALLOC_FAIL, OPUS_BANDWIDTH_NARROWBAND, OPUS_BANDWIDTH_MEDIUMBAND, OPUS_BANDWIDTH_WIDEBAND, OPUS_BANDWIDTH_SUPERWIDEBAND, OPUS_BANDWIDTH_FULLBAND, OPUS_SIGNAL_VOICE, OPUS_SIGNAL_MUSIC, MAX_FRAME_SIZE, MAX_PACKET_SIZE, MAX_CHANNELS, } from './lib/opus-constants';
+export type { OpusModule, DecodedAudio, OpusDecoderOptions, OpusEncoderOptions, OpusModuleFactory, } from './lib/types';

package/index.js

@@ -0,0 +1,45 @@
+import { OpusDecoder as S } from "./lib/opus-decoder.js";
+import { OpusEncoder as O } from "./lib/opus-encoder.js";
+import { getOpusModule as P, isModuleLoaded as A, isSimdSupported as I } from "./lib/opus-module.js";
+import { MAX_CHANNELS as D, MAX_FRAME_SIZE as N, MAX_PACKET_SIZE as L, OPUS_ALLOC_FAIL as B, OPUS_APPLICATION_AUDIO as C, OPUS_APPLICATION_RESTRICTED_LOWDELAY as o, OPUS_APPLICATION_VOIP as M, OPUS_BAD_ARG as e, OPUS_BANDWIDTH_FULLBAND as Q, OPUS_BANDWIDTH_MEDIUMBAND as r, OPUS_BANDWIDTH_NARROWBAND as p, OPUS_BANDWIDTH_SUPERWIDEBAND as G, OPUS_BANDWIDTH_WIDEBAND as W, OPUS_BUFFER_TOO_SMALL as d, OPUS_GET_BITRATE_REQUEST as F, OPUS_GET_COMPLEXITY_REQUEST as X, OPUS_GET_DTX_REQUEST as t, OPUS_GET_INBAND_FEC_REQUEST as u, OPUS_GET_PACKET_LOSS_PERC_REQUEST as H, OPUS_GET_VBR_REQUEST as V, OPUS_INTERNAL_ERROR as m, OPUS_INVALID_PACKET as s, OPUS_INVALID_STATE as K, OPUS_OK as f, OPUS_RESET_STATE as x, OPUS_SET_BITRATE_REQUEST as i, OPUS_SET_COMPLEXITY_REQUEST as Y, OPUS_SET_DTX_REQUEST as c, OPUS_SET_INBAND_FEC_REQUEST as l, OPUS_SET_PACKET_LOSS_PERC_REQUEST as Z, OPUS_SET_VBR_REQUEST as a, OPUS_SIGNAL_MUSIC as g, OPUS_SIGNAL_VOICE as n, OPUS_UNIMPLEMENTED as b } from "./lib/opus-constants.js";
+export {
+  D as MAX_CHANNELS,
+  N as MAX_FRAME_SIZE,
+  L as MAX_PACKET_SIZE,
+  B as OPUS_ALLOC_FAIL,
+  C as OPUS_APPLICATION_AUDIO,
+  o as OPUS_APPLICATION_RESTRICTED_LOWDELAY,
+  M as OPUS_APPLICATION_VOIP,
+  e as OPUS_BAD_ARG,
+  Q as OPUS_BANDWIDTH_FULLBAND,
+  r as OPUS_BANDWIDTH_MEDIUMBAND,
+  p as OPUS_BANDWIDTH_NARROWBAND,
+  G as OPUS_BANDWIDTH_SUPERWIDEBAND,
+  W as OPUS_BANDWIDTH_WIDEBAND,
+  d as OPUS_BUFFER_TOO_SMALL,
+  F as OPUS_GET_BITRATE_REQUEST,
+  X as OPUS_GET_COMPLEXITY_REQUEST,
+  t as OPUS_GET_DTX_REQUEST,
+  u as OPUS_GET_INBAND_FEC_REQUEST,
+  H as OPUS_GET_PACKET_LOSS_PERC_REQUEST,
+  V as OPUS_GET_VBR_REQUEST,
+  m as OPUS_INTERNAL_ERROR,
+  s as OPUS_INVALID_PACKET,
+  K as OPUS_INVALID_STATE,
+  f as OPUS_OK,
+  x as OPUS_RESET_STATE,
+  i as OPUS_SET_BITRATE_REQUEST,
+  Y as OPUS_SET_COMPLEXITY_REQUEST,
+  c as OPUS_SET_DTX_REQUEST,
+  l as OPUS_SET_INBAND_FEC_REQUEST,
+  Z as OPUS_SET_PACKET_LOSS_PERC_REQUEST,
+  a as OPUS_SET_VBR_REQUEST,
+  g as OPUS_SIGNAL_MUSIC,
+  n as OPUS_SIGNAL_VOICE,
+  b as OPUS_UNIMPLEMENTED,
+  S as OpusDecoder,
+  O as OpusEncoder,
+  P as getOpusModule,
+  A as isModuleLoaded,
+  I as isSimdSupported
+};

package/lib/opus-constants.d.ts

@@ -0,0 +1,45 @@
+export declare const OPUS_APPLICATION_VOIP = 2048;
+export declare const OPUS_APPLICATION_AUDIO = 2049;
+export declare const OPUS_APPLICATION_RESTRICTED_LOWDELAY = 2051;
+export declare const OPUS_SET_BITRATE_REQUEST = 4002;
+export declare const OPUS_GET_BITRATE_REQUEST = 4003;
+export declare const OPUS_SET_COMPLEXITY_REQUEST = 4010;
+export declare const OPUS_GET_COMPLEXITY_REQUEST = 4011;
+export declare const OPUS_SET_VBR_REQUEST = 4006;
+export declare const OPUS_GET_VBR_REQUEST = 4007;
+export declare const OPUS_SET_VBR_CONSTRAINT_REQUEST = 4020;
+export declare const OPUS_GET_VBR_CONSTRAINT_REQUEST = 4021;
+export declare const OPUS_SET_FORCE_CHANNELS_REQUEST = 4022;
+export declare const OPUS_GET_FORCE_CHANNELS_REQUEST = 4023;
+export declare const OPUS_SET_MAX_BANDWIDTH_REQUEST = 4004;
+export declare const OPUS_GET_MAX_BANDWIDTH_REQUEST = 4005;
+export declare const OPUS_SET_BANDWIDTH_REQUEST = 4008;
+export declare const OPUS_SET_SIGNAL_REQUEST = 4024;
+export declare const OPUS_GET_SIGNAL_REQUEST = 4025;
+export declare const OPUS_SET_DTX_REQUEST = 4016;
+export declare const OPUS_GET_DTX_REQUEST = 4017;
+export declare const OPUS_SET_INBAND_FEC_REQUEST = 4012;
+export declare const OPUS_GET_INBAND_FEC_REQUEST = 4013;
+export declare const OPUS_SET_PACKET_LOSS_PERC_REQUEST = 4014;
+export declare const OPUS_GET_PACKET_LOSS_PERC_REQUEST = 4015;
+export declare const OPUS_RESET_STATE = 4028;
+export declare const OPUS_GET_SAMPLE_RATE_REQUEST = 4029;
+export declare const OPUS_GET_LOOKAHEAD_REQUEST = 4027;
+export declare const OPUS_OK = 0;
+export declare const OPUS_BAD_ARG = -1;
+export declare const OPUS_BUFFER_TOO_SMALL = -2;
+export declare const OPUS_INTERNAL_ERROR = -3;
+export declare const OPUS_INVALID_PACKET = -4;
+export declare const OPUS_UNIMPLEMENTED = -5;
+export declare const OPUS_INVALID_STATE = -6;
+export declare const OPUS_ALLOC_FAIL = -7;
+export declare const OPUS_BANDWIDTH_NARROWBAND = 1101;
+export declare const OPUS_BANDWIDTH_MEDIUMBAND = 1102;
+export declare const OPUS_BANDWIDTH_WIDEBAND = 1103;
+export declare const OPUS_BANDWIDTH_SUPERWIDEBAND = 1104;
+export declare const OPUS_BANDWIDTH_FULLBAND = 1105;
+export declare const OPUS_SIGNAL_VOICE = 3001;
+export declare const OPUS_SIGNAL_MUSIC = 3002;
+export declare const MAX_FRAME_SIZE = 5760;
+export declare const MAX_PACKET_SIZE = 4000;
+export declare const MAX_CHANNELS = 2;

package/lib/opus-constants.js

@@ -0,0 +1,37 @@
+const _ = 2048, E = 2049, S = 2051, T = 4002, U = 4003, O = 4010, P = 4011, A = 4006, I = 4007, o = 4016, t = 4017, c = 4012, n = 4013, s = 4014, R = 4015, D = 4028, N = 0, L = -1, B = -2, C = -3, M = -4, Q = -5, G = -6, W = -7, F = 1101, X = 1102, H = 1103, V = 1104, K = 1105, Y = 3001, e = 3002, Z = 5760, p = 4e3, r = 2;
+export {
+  r as MAX_CHANNELS,
+  Z as MAX_FRAME_SIZE,
+  p as MAX_PACKET_SIZE,
+  W as OPUS_ALLOC_FAIL,
+  E as OPUS_APPLICATION_AUDIO,
+  S as OPUS_APPLICATION_RESTRICTED_LOWDELAY,
+  _ as OPUS_APPLICATION_VOIP,
+  L as OPUS_BAD_ARG,
+  K as OPUS_BANDWIDTH_FULLBAND,
+  X as OPUS_BANDWIDTH_MEDIUMBAND,
+  F as OPUS_BANDWIDTH_NARROWBAND,
+  V as OPUS_BANDWIDTH_SUPERWIDEBAND,
+  H as OPUS_BANDWIDTH_WIDEBAND,
+  B as OPUS_BUFFER_TOO_SMALL,
+  U as OPUS_GET_BITRATE_REQUEST,
+  P as OPUS_GET_COMPLEXITY_REQUEST,
+  t as OPUS_GET_DTX_REQUEST,
+  n as OPUS_GET_INBAND_FEC_REQUEST,
+  R as OPUS_GET_PACKET_LOSS_PERC_REQUEST,
+  I as OPUS_GET_VBR_REQUEST,
+  C as OPUS_INTERNAL_ERROR,
+  M as OPUS_INVALID_PACKET,
+  G as OPUS_INVALID_STATE,
+  N as OPUS_OK,
+  D as OPUS_RESET_STATE,
+  T as OPUS_SET_BITRATE_REQUEST,
+  O as OPUS_SET_COMPLEXITY_REQUEST,
+  o as OPUS_SET_DTX_REQUEST,
+  c as OPUS_SET_INBAND_FEC_REQUEST,
+  s as OPUS_SET_PACKET_LOSS_PERC_REQUEST,
+  A as OPUS_SET_VBR_REQUEST,
+  e as OPUS_SIGNAL_MUSIC,
+  Y as OPUS_SIGNAL_VOICE,
+  Q as OPUS_UNIMPLEMENTED
+};

package/lib/opus-decoder.d.ts

@@ -0,0 +1,54 @@
+import { DecodedAudio, OpusDecoderOptions } from './types';
+/**
+ * Opus audio decoder with zero per-frame allocations.
+ *
+ * All buffers are pre-allocated at construction time and reused for each decode call.
+ * The decoded audio is returned as views into internal buffers - callers must copy
+ * the data if they need it to persist beyond the next decode call.
+ */
+export declare class OpusDecoder {
+    private module;
+    private decoder;
+    private readonly channels;
+    private readonly sampleRate;
+    private inputPtr;
+    private outputPtr;
+    private readonly channelBuffers;
+    readonly ready: Promise<void>;
+    constructor(options: OpusDecoderOptions);
+    private initialize;
+    /**
+     * Decode an Opus frame.
+     *
+     * Returns views into pre-allocated buffers. The channelData arrays are reused
+     * on each call, so callers MUST copy the data if it needs to persist beyond
+     * the next decode call.
+     *
+     * @param opusData - The Opus-encoded audio frame
+     * @returns Decoded audio with channel data and sample count
+     */
+    decodeFrame(opusData: Uint8Array): DecodedAudio;
+    /**
+     * Decode a frame and copy the result (when caller needs ownership).
+     * Use this when you need the decoded audio to persist.
+     */
+    decodeFrameAndCopy(opusData: Uint8Array): DecodedAudio;
+    /**
+     * Reset the decoder state.
+     * Call this when there's a discontinuity in the audio stream.
+     */
+    reset(): void;
+    /**
+     * Get the number of channels this decoder was created with.
+     */
+    getChannels(): number;
+    /**
+     * Get the sample rate this decoder was created with.
+     */
+    getSampleRate(): number;
+    /**
+     * Release all resources.
+     * The decoder cannot be used after calling destroy().
+     */
+    destroy(): void;
+}

package/lib/opus-decoder.js

@@ -0,0 +1,106 @@
+import { getOpusModule as d } from "./opus-module.js";
+import { MAX_FRAME_SIZE as i, MAX_PACKET_SIZE as h, OPUS_RESET_STATE as a } from "./opus-constants.js";
+class m {
+  module = null;
+  decoder = 0;
+  channels;
+  sampleRate;
+  // Pre-allocated WASM heap pointers (allocated once, reused)
+  inputPtr = 0;
+  outputPtr = 0;
+  // Pre-allocated output arrays (reused, caller must copy if needed)
+  channelBuffers;
+  ready;
+  constructor(e) {
+    this.channels = e.channels, this.sampleRate = e.sampleRate, this.channelBuffers = Array.from({ length: this.channels }, () => new Float32Array(i)), this.ready = this.initialize();
+  }
+  async initialize() {
+    this.module = await d();
+    const e = this.module._malloc(4);
+    this.decoder = this.module._opus_decoder_create(this.sampleRate, this.channels, e);
+    const t = new DataView(this.module.HEAPU8.buffer).getInt32(e, !0);
+    if (this.module._free(e), t !== 0)
+      throw new Error(`opus_decoder_create failed with error code ${t}`);
+    this.inputPtr = this.module._malloc(h), this.outputPtr = this.module._malloc(i * this.channels * 4);
+  }
+  /**
+   * Decode an Opus frame.
+   *
+   * Returns views into pre-allocated buffers. The channelData arrays are reused
+   * on each call, so callers MUST copy the data if it needs to persist beyond
+   * the next decode call.
+   *
+   * @param opusData - The Opus-encoded audio frame
+   * @returns Decoded audio with channel data and sample count
+   */
+  decodeFrame(e) {
+    if (!this.module || !this.decoder)
+      throw new Error("Decoder not initialized");
+    if (e.length > h)
+      throw new Error(`Opus packet too large: ${e.length} > ${h}`);
+    this.module.HEAPU8.set(e, this.inputPtr);
+    const t = this.module._opus_decode_float(
+      this.decoder,
+      this.inputPtr,
+      e.length,
+      this.outputPtr,
+      i,
+      0
+      // decodeFec = false
+    );
+    if (t < 0)
+      throw new Error(`opus_decode_float failed with error code ${t}`);
+    const o = this.outputPtr / 4;
+    for (let s = 0; s < this.channels; s++) {
+      const l = this.channelBuffers[s];
+      for (let r = 0; r < t; r++)
+        l[r] = this.module.HEAPF32[o + r * this.channels + s];
+    }
+    return {
+      channelData: this.channelBuffers,
+      samplesDecoded: t,
+      sampleRate: this.sampleRate
+    };
+  }
+  /**
+   * Decode a frame and copy the result (when caller needs ownership).
+   * Use this when you need the decoded audio to persist.
+   */
+  decodeFrameAndCopy(e) {
+    const t = this.decodeFrame(e);
+    return {
+      channelData: t.channelData.map((o) => o.slice(0, t.samplesDecoded)),
+      samplesDecoded: t.samplesDecoded,
+      sampleRate: t.sampleRate
+    };
+  }
+  /**
+   * Reset the decoder state.
+   * Call this when there's a discontinuity in the audio stream.
+   */
+  reset() {
+    this.module && this.decoder && this.module._opus_decoder_ctl(this.decoder, a);
+  }
+  /**
+   * Get the number of channels this decoder was created with.
+   */
+  getChannels() {
+    return this.channels;
+  }
+  /**
+   * Get the sample rate this decoder was created with.
+   */
+  getSampleRate() {
+    return this.sampleRate;
+  }
+  /**
+   * Release all resources.
+   * The decoder cannot be used after calling destroy().
+   */
+  destroy() {
+    this.module && (this.decoder && this.module._opus_decoder_destroy(this.decoder), this.inputPtr && this.module._free(this.inputPtr), this.outputPtr && this.module._free(this.outputPtr)), this.decoder = 0, this.inputPtr = 0, this.outputPtr = 0, this.module = null;
+  }
+}
+export {
+  m as OpusDecoder
+};

package/lib/opus-encoder.d.ts

@@ -0,0 +1,66 @@
+import { OpusEncoderOptions } from './types';
+/**
+ * Opus audio encoder with zero per-frame allocations.
+ *
+ * All buffers are pre-allocated at construction time and reused for each encode call.
+ * The encoded audio is returned as a view into an internal buffer - callers must copy
+ * the data if they need it to persist beyond the next encode call.
+ */
+export declare class OpusEncoder {
+    private module;
+    private encoder;
+    private readonly channels;
+    private readonly sampleRate;
+    private readonly bitrate;
+    private readonly application;
+    private inputPtr;
+    private outputPtr;
+    readonly ready: Promise<void>;
+    constructor(options: OpusEncoderOptions);
+    private initialize;
+    private setEncoderCtl;
+    /**
+     * Encode PCM float samples to Opus.
+     *
+     * Returns a view into a pre-allocated buffer. The returned Uint8Array is reused
+     * on each call, so callers MUST copy the data if it needs to persist beyond
+     * the next encode call.
+     *
+     * @param pcmFloat - Interleaved float PCM samples (-1.0 to 1.0)
+     * @returns Opus-encoded audio data (view into internal buffer)
+     */
+    encode(pcmFloat: Float32Array): Uint8Array;
+    /**
+     * Encode and copy the result (when caller needs ownership).
+     * Use this when you need the encoded audio to persist, e.g., when sending to another thread.
+     */
+    encodeAndCopy(pcmFloat: Float32Array): Uint8Array;
+    /**
+     * Reset the encoder state.
+     * Call this when there's a discontinuity in the audio stream.
+     */
+    reset(): void;
+    /**
+     * Set the encoder bitrate.
+     * @param bitrate - Target bitrate in bits per second
+     */
+    setBitrate(bitrate: number): void;
+    /**
+     * Set the encoder complexity (0-10, higher = better quality but more CPU).
+     * @param complexity - Complexity value (0-10)
+     */
+    setComplexity(complexity: number): void;
+    /**
+     * Get the number of channels this encoder was created with.
+     */
+    getChannels(): number;
+    /**
+     * Get the sample rate this encoder was created with.
+     */
+    getSampleRate(): number;
+    /**
+     * Release all resources.
+     * The encoder cannot be used after calling destroy().
+     */
+    destroy(): void;
+}

package/lib/opus-encoder.js

@@ -0,0 +1,117 @@
+import { getOpusModule as l } from "./opus-module.js";
+import { OPUS_APPLICATION_VOIP as u, OPUS_SET_BITRATE_REQUEST as o, OPUS_SET_COMPLEXITY_REQUEST as n, MAX_PACKET_SIZE as h, OPUS_RESET_STATE as d } from "./opus-constants.js";
+const r = 2880;
+class _ {
+  module = null;
+  encoder = 0;
+  channels;
+  sampleRate;
+  bitrate;
+  application;
+  // Pre-allocated WASM heap pointers
+  inputPtr = 0;
+  outputPtr = 0;
+  ready;
+  constructor(t) {
+    this.channels = t.channels, this.sampleRate = t.sampleRate, this.bitrate = t.bitrate ?? 32e3, this.application = t.application ?? u, this.ready = this.initialize(t);
+  }
+  async initialize(t) {
+    this.module = await l();
+    const e = this.module._malloc(4);
+    this.encoder = this.module._opus_encoder_create(
+      this.sampleRate,
+      this.channels,
+      this.application,
+      e
+    );
+    const i = new DataView(this.module.HEAPU8.buffer).getInt32(e, !0);
+    if (this.module._free(e), i !== 0)
+      throw new Error(`opus_encoder_create failed with error code ${i}`);
+    this.setEncoderCtl(o, this.bitrate), t.complexity !== void 0 && this.setEncoderCtl(n, t.complexity), this.inputPtr = this.module._malloc(r * this.channels * 4), this.outputPtr = this.module._malloc(h);
+  }
+  setEncoderCtl(t, e) {
+    if (!this.module || !this.encoder)
+      return;
+    const i = this.module._malloc(4);
+    new DataView(this.module.HEAPU8.buffer).setInt32(i, e, !0), this.module._opus_encoder_ctl(this.encoder, t, i), this.module._free(i);
+  }
+  /**
+   * Encode PCM float samples to Opus.
+   *
+   * Returns a view into a pre-allocated buffer. The returned Uint8Array is reused
+   * on each call, so callers MUST copy the data if it needs to persist beyond
+   * the next encode call.
+   *
+   * @param pcmFloat - Interleaved float PCM samples (-1.0 to 1.0)
+   * @returns Opus-encoded audio data (view into internal buffer)
+   */
+  encode(t) {
+    if (!this.module || !this.encoder)
+      throw new Error("Encoder not initialized");
+    const e = t.length / this.channels;
+    if (e > r)
+      throw new Error(`Frame size too large: ${e} > ${r} samples`);
+    const i = this.inputPtr / 4;
+    this.module.HEAPF32.set(t, i);
+    const s = this.module._opus_encode_float(
+      this.encoder,
+      this.inputPtr,
+      e,
+      this.outputPtr,
+      h
+    );
+    if (s < 0)
+      throw new Error(`opus_encode_float failed with error code ${s}`);
+    return new Uint8Array(this.module.HEAPU8.buffer, this.outputPtr, s);
+  }
+  /**
+   * Encode and copy the result (when caller needs ownership).
+   * Use this when you need the encoded audio to persist, e.g., when sending to another thread.
+   */
+  encodeAndCopy(t) {
+    return this.encode(t).slice();
+  }
+  /**
+   * Reset the encoder state.
+   * Call this when there's a discontinuity in the audio stream.
+   */
+  reset() {
+    this.module && this.encoder && this.module._opus_encoder_ctl(this.encoder, d);
+  }
+  /**
+   * Set the encoder bitrate.
+   * @param bitrate - Target bitrate in bits per second
+   */
+  setBitrate(t) {
+    this.setEncoderCtl(o, t);
+  }
+  /**
+   * Set the encoder complexity (0-10, higher = better quality but more CPU).
+   * @param complexity - Complexity value (0-10)
+   */
+  setComplexity(t) {
+    this.setEncoderCtl(n, t);
+  }
+  /**
+   * Get the number of channels this encoder was created with.
+   */
+  getChannels() {
+    return this.channels;
+  }
+  /**
+   * Get the sample rate this encoder was created with.
+   */
+  getSampleRate() {
+    return this.sampleRate;
+  }
+  /**
+   * Release all resources.
+   * The encoder cannot be used after calling destroy().
+   */
+  destroy() {
+    this.module && (this.encoder && this.module._opus_encoder_destroy(this.encoder), this.inputPtr && this.module._free(this.inputPtr), this.outputPtr && this.module._free(this.outputPtr)), this.encoder = 0, this.inputPtr = 0, this.outputPtr = 0, this.module = null;
+  }
+}
+export {
+  _ as OpusEncoder
+};

package/lib/opus-module.d.ts

@@ -0,0 +1,15 @@
+import { OpusModule } from './types';
+/**
+ * Get the shared OpusModule instance.
+ * The module is loaded lazily on first call and cached for subsequent calls.
+ * Automatically selects SIMD or non-SIMD version based on browser support.
+ */
+export declare function getOpusModule(): Promise<OpusModule>;
+/**
+ * Check if the OpusModule has been loaded.
+ */
+export declare function isModuleLoaded(): boolean;
+/**
+ * Check if SIMD is supported by the current browser.
+ */
+export declare function isSimdSupported(): Promise<boolean>;

package/lib/opus-module.js

@@ -0,0 +1,72 @@
+let r = null, t = null;
+const i = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  // magic
+  1,
+  0,
+  0,
+  0,
+  // version
+  1,
+  5,
+  1,
+  96,
+  0,
+  1,
+  123,
+  // type section: () -> v128
+  3,
+  2,
+  1,
+  0,
+  // function section
+  10,
+  10,
+  1,
+  8,
+  0,
+  // code section start
+  65,
+  0,
+  // i32.const 0
+  253,
+  15,
+  // v128.load (SIMD)
+  253,
+  98,
+  // i32x4.extract_lane 0
+  11
+  // end
+]);
+async function o() {
+  try {
+    return WebAssembly.validate(i);
+  } catch {
+    return !1;
+  }
+}
+async function s() {
+  return t || (r || (r = (async () => {
+    const a = await o();
+    let n;
+    a ? n = (await import("../wasm/libopus-simd.js")).default : n = (await import("../wasm/libopus.js")).default;
+    const u = a ? "../wasm/libopus-simd.wasm" : "../wasm/libopus.wasm";
+    return t = await n({
+      locateFile: (e) => e.endsWith(".wasm") ? new URL(u, import.meta.url).href : e
+    }), t;
+  })()), r);
+}
+function l() {
+  return t !== null;
+}
+async function d() {
+  return o();
+}
+export {
+  s as getOpusModule,
+  l as isModuleLoaded,
+  d as isSimdSupported
+};

package/lib/types.d.ts

@@ -0,0 +1,35 @@
+export interface OpusModule {
+    _opus_decoder_create(sampleRate: number, channels: number, errorPtr: number): number;
+    _opus_decode_float(decoder: number, data: number, len: number, pcm: number, frameSize: number, decodeFec: number): number;
+    _opus_decoder_destroy(decoder: number): void;
+    _opus_decoder_ctl(decoder: number, request: number, ...args: number[]): number;
+    _opus_encoder_create(sampleRate: number, channels: number, application: number, errorPtr: number): number;
+    _opus_encode_float(encoder: number, pcm: number, frameSize: number, data: number, maxDataBytes: number): number;
+    _opus_encoder_destroy(encoder: number): void;
+    _opus_encoder_ctl(encoder: number, request: number, ...args: number[]): number;
+    _opus_strerror(error: number): number;
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+    HEAPU8: Uint8Array;
+    HEAPF32: Float32Array;
+}
+export interface DecodedAudio {
+    channelData: Float32Array[];
+    samplesDecoded: number;
+    sampleRate: number;
+}
+export interface OpusDecoderOptions {
+    channels: number;
+    sampleRate: number;
+}
+export interface OpusEncoderOptions {
+    channels: number;
+    sampleRate: number;
+    bitrate?: number;
+    frameSize?: number;
+    application?: number;
+    complexity?: number;
+}
+export type OpusModuleFactory = (options?: {
+    locateFile?: (path: string) => string;
+}) => Promise<OpusModule>;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ikonai/sdk-libopus",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./wasm/*": {
+      "import": "./wasm/*"
+    }
+  }
+}

package/wasm/libopus-simd.d.ts

@@ -0,0 +1,3 @@
+import type { OpusModuleFactory } from '../lib/types';
+declare const createOpusModule: OpusModuleFactory;
+export default createOpusModule;

package/wasm/libopus-simd.js

@@ -0,0 +1,13 @@
+async function Module(moduleArg={}){var moduleRtn;var b=moduleArg,m=!!globalThis.WorkerGlobalScope,aa=import.meta.url,n="",p,r;if(globalThis.window||m){try{n=(new URL(".",aa)).href}catch{}m&&(r=a=>{var c=new XMLHttpRequest;c.open("GET",a,!1);c.responseType="arraybuffer";c.send(null);return new Uint8Array(c.response)});p=async a=>{a=await fetch(a,{credentials:"same-origin"});if(a.ok)return a.arrayBuffer();throw Error(a.status+" : "+a.url);}}var t=console.log.bind(console),u=console.error.bind(console),v,x=!1,y,z,A,B,C,D=!1;
+function I(){var a=J.buffer;new Int8Array(a);new Int16Array(a);b.HEAPU8=B=new Uint8Array(a);new Uint16Array(a);new Int32Array(a);C=new Uint32Array(a);b.HEAPF32=new Float32Array(a);new Float64Array(a);new BigInt64Array(a);new BigUint64Array(a)}function K(a){b.onAbort?.(a);a="Aborted("+a+")";u(a);x=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");A?.(a);throw a;}var L;
+async function ba(a){if(!v)try{var c=await p(a);return new Uint8Array(c)}catch{}if(a==L&&v)a=new Uint8Array(v);else if(r)a=r(a);else throw"both async and sync fetching of the wasm failed";return a}async function ca(a,c){try{var d=await ba(a);return await WebAssembly.instantiate(d,c)}catch(f){u(`failed to asynchronously prepare wasm: ${f}`),K(f)}}
+async function da(a){var c=L;if(!v)try{var d=fetch(c,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(d,a)}catch(f){u(`wasm streaming compile failed: ${f}`),u("falling back to ArrayBuffer instantiation")}return ca(c,a)}class M{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
+var N=a=>{for(;0<a.length;)a.shift()(b)},O=[],P=[],ea=()=>{var a=b.preRun.shift();P.push(a)},Q=!0,R=0,S={},T=a=>{if(!(a instanceof M||"unwind"==a))throw a;},U=a=>{y=a;Q||0<R||(b.onExit?.(a),x=!0);throw new M(a);},fa=a=>{if(!x)try{if(a(),!(Q||0<R))try{y=a=y,U(a)}catch(c){T(c)}}catch(c){T(c)}},ha=[null,[],[]],V=globalThis.TextDecoder&&new TextDecoder;b.noExitRuntime&&(Q=b.noExitRuntime);b.print&&(t=b.print);b.printErr&&(u=b.printErr);b.wasmBinary&&(v=b.wasmBinary);
+if(b.preInit)for("function"==typeof b.preInit&&(b.preInit=[b.preInit]);0<b.preInit.length;)b.preInit.shift()();
+var W,J,ja={e:()=>K(""),b:()=>{Q=!1;R=0},c:(a,c)=>{S[a]&&(clearTimeout(S[a].id),delete S[a]);if(!c)return 0;var d=setTimeout(()=>{delete S[a];fa(()=>W(a,performance.now()))},c);S[a]={id:d,u:c};return 0},d:a=>{var c=B.length;a>>>=0;if(67108864<a)return!1;for(var d=1;4>=d;d*=2){var f=c*(1+.2/d);f=Math.min(f,a+100663296);a:{f=(Math.min(67108864,65536*Math.ceil(Math.max(a,f)/65536))-J.buffer.byteLength+65535)/65536|0;try{J.grow(f);I();var l=1;break a}catch(E){}l=void 0}if(l)return!0}return!1},f:(a,c,
+d,f)=>{for(var l=0,E=0;E<d;E++){var ia=C[c>>2],Y=C[c+4>>2];c+=8;for(var F=0;F<Y;F++){var w=a,g=B[ia+F],G=ha[w];if(0===g||10===g){w=1===w?t:u;g=G;var k=0;var q=g;for(var h=k,e=h+void 0;q[h]&&!(h>=e);)++h;q=h;if(16<q-k&&g.buffer&&V)g=V.decode(g.subarray(k,q));else{for(h="";k<q;)if(e=g[k++],e&128){var H=g[k++]&63;if(192==(e&224))h+=String.fromCharCode((e&31)<<6|H);else{var Z=g[k++]&63;e=224==(e&240)?(e&15)<<12|H<<6|Z:(e&7)<<18|H<<12|Z<<6|g[k++]&63;65536>e?h+=String.fromCharCode(e):(e-=65536,h+=String.fromCharCode(55296|
+e>>10,56320|e&1023))}}else h+=String.fromCharCode(e);g=h}w(g);G.length=0}else G.push(g)}l+=Y}C[f>>2]=l;return 0},a:U},X;
+X=await (async function(){function a(d){d=X=d.exports;b._opus_strerror=d.i;b._opus_decoder_create=d.j;b._opus_decode_float=d.k;b._opus_decoder_ctl=d.l;b._opus_decoder_destroy=d.m;b._opus_encoder_create=d.n;b._opus_encode_float=d.o;b._opus_encoder_ctl=d.p;b._opus_encoder_destroy=d.q;W=d.r;b._malloc=d.s;b._free=d.t;J=d.g;I();return X}var c={a:ja};if(b.instantiateWasm)return new Promise(d=>{b.instantiateWasm(c,(f,l)=>{d(a(f,l))})});L??=b.locateFile?b.locateFile?b.locateFile("libopus-simd.wasm",
+n):n+"libopus-simd.wasm":(new URL("libopus-simd.wasm",import.meta.url)).href;return a((await da(c)).instance)}());
+(function(){function a(){b.calledRun=!0;if(!x){D=!0;X.h();z?.(b);b.onRuntimeInitialized?.();if(b.postRun)for("function"==typeof b.postRun&&(b.postRun=[b.postRun]);b.postRun.length;){var c=b.postRun.shift();O.push(c)}N(O)}}if(b.preRun)for("function"==typeof b.preRun&&(b.preRun=[b.preRun]);b.preRun.length;)ea();N(P);b.setStatus?(b.setStatus("Running..."),setTimeout(()=>{setTimeout(()=>b.setStatus(""),1);a()},1)):a()})();D?moduleRtn=b:moduleRtn=new Promise((a,c)=>{z=a;A=c});
+;return moduleRtn}export default Module;

package/wasm/libopus.d.ts

@@ -0,0 +1,3 @@
+import type { OpusModuleFactory } from '../lib/types';
+declare const createOpusModule: OpusModuleFactory;
+export default createOpusModule;

package/wasm/libopus.js

@@ -0,0 +1,13 @@
+async function Module(moduleArg={}){var moduleRtn;var b=moduleArg,m=!!globalThis.WorkerGlobalScope,aa=import.meta.url,n="",p,r;if(globalThis.window||m){try{n=(new URL(".",aa)).href}catch{}m&&(r=a=>{var c=new XMLHttpRequest;c.open("GET",a,!1);c.responseType="arraybuffer";c.send(null);return new Uint8Array(c.response)});p=async a=>{a=await fetch(a,{credentials:"same-origin"});if(a.ok)return a.arrayBuffer();throw Error(a.status+" : "+a.url);}}var t=console.log.bind(console),u=console.error.bind(console),v,x=!1,y,z,A,B,C,D=!1;
+function I(){var a=J.buffer;new Int8Array(a);new Int16Array(a);b.HEAPU8=B=new Uint8Array(a);new Uint16Array(a);new Int32Array(a);C=new Uint32Array(a);b.HEAPF32=new Float32Array(a);new Float64Array(a);new BigInt64Array(a);new BigUint64Array(a)}function K(a){b.onAbort?.(a);a="Aborted("+a+")";u(a);x=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");A?.(a);throw a;}var L;
+async function ba(a){if(!v)try{var c=await p(a);return new Uint8Array(c)}catch{}if(a==L&&v)a=new Uint8Array(v);else if(r)a=r(a);else throw"both async and sync fetching of the wasm failed";return a}async function ca(a,c){try{var d=await ba(a);return await WebAssembly.instantiate(d,c)}catch(f){u(`failed to asynchronously prepare wasm: ${f}`),K(f)}}
+async function da(a){var c=L;if(!v)try{var d=fetch(c,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(d,a)}catch(f){u(`wasm streaming compile failed: ${f}`),u("falling back to ArrayBuffer instantiation")}return ca(c,a)}class M{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
+var N=a=>{for(;0<a.length;)a.shift()(b)},O=[],P=[],ea=()=>{var a=b.preRun.shift();P.push(a)},Q=!0,R=0,S={},T=a=>{if(!(a instanceof M||"unwind"==a))throw a;},U=a=>{y=a;Q||0<R||(b.onExit?.(a),x=!0);throw new M(a);},fa=a=>{if(!x)try{if(a(),!(Q||0<R))try{y=a=y,U(a)}catch(c){T(c)}}catch(c){T(c)}},ha=[null,[],[]],V=globalThis.TextDecoder&&new TextDecoder;b.noExitRuntime&&(Q=b.noExitRuntime);b.print&&(t=b.print);b.printErr&&(u=b.printErr);b.wasmBinary&&(v=b.wasmBinary);
+if(b.preInit)for("function"==typeof b.preInit&&(b.preInit=[b.preInit]);0<b.preInit.length;)b.preInit.shift()();
+var W,J,ja={e:()=>K(""),b:()=>{Q=!1;R=0},c:(a,c)=>{S[a]&&(clearTimeout(S[a].id),delete S[a]);if(!c)return 0;var d=setTimeout(()=>{delete S[a];fa(()=>W(a,performance.now()))},c);S[a]={id:d,u:c};return 0},d:a=>{var c=B.length;a>>>=0;if(67108864<a)return!1;for(var d=1;4>=d;d*=2){var f=c*(1+.2/d);f=Math.min(f,a+100663296);a:{f=(Math.min(67108864,65536*Math.ceil(Math.max(a,f)/65536))-J.buffer.byteLength+65535)/65536|0;try{J.grow(f);I();var l=1;break a}catch(E){}l=void 0}if(l)return!0}return!1},f:(a,c,
+d,f)=>{for(var l=0,E=0;E<d;E++){var ia=C[c>>2],Y=C[c+4>>2];c+=8;for(var F=0;F<Y;F++){var w=a,g=B[ia+F],G=ha[w];if(0===g||10===g){w=1===w?t:u;g=G;var k=0;var q=g;for(var h=k,e=h+void 0;q[h]&&!(h>=e);)++h;q=h;if(16<q-k&&g.buffer&&V)g=V.decode(g.subarray(k,q));else{for(h="";k<q;)if(e=g[k++],e&128){var H=g[k++]&63;if(192==(e&224))h+=String.fromCharCode((e&31)<<6|H);else{var Z=g[k++]&63;e=224==(e&240)?(e&15)<<12|H<<6|Z:(e&7)<<18|H<<12|Z<<6|g[k++]&63;65536>e?h+=String.fromCharCode(e):(e-=65536,h+=String.fromCharCode(55296|
+e>>10,56320|e&1023))}}else h+=String.fromCharCode(e);g=h}w(g);G.length=0}else G.push(g)}l+=Y}C[f>>2]=l;return 0},a:U},X;
+X=await (async function(){function a(d){d=X=d.exports;b._opus_strerror=d.i;b._opus_decoder_create=d.j;b._opus_decode_float=d.k;b._opus_decoder_ctl=d.l;b._opus_decoder_destroy=d.m;b._opus_encoder_create=d.n;b._opus_encode_float=d.o;b._opus_encoder_ctl=d.p;b._opus_encoder_destroy=d.q;W=d.r;b._malloc=d.s;b._free=d.t;J=d.g;I();return X}var c={a:ja};if(b.instantiateWasm)return new Promise(d=>{b.instantiateWasm(c,(f,l)=>{d(a(f,l))})});L??=b.locateFile?b.locateFile?b.locateFile("libopus.wasm",
+n):n+"libopus.wasm":(new URL("libopus.wasm",import.meta.url)).href;return a((await da(c)).instance)}());
+(function(){function a(){b.calledRun=!0;if(!x){D=!0;X.h();z?.(b);b.onRuntimeInitialized?.();if(b.postRun)for("function"==typeof b.postRun&&(b.postRun=[b.postRun]);b.postRun.length;){var c=b.postRun.shift();O.push(c)}N(O)}}if(b.preRun)for("function"==typeof b.preRun&&(b.preRun=[b.preRun]);b.preRun.length;)ea();N(P);b.setStatus?(b.setStatus("Running..."),setTimeout(()=>{setTimeout(()=>b.setStatus(""),1);a()},1)):a()})();D?moduleRtn=b:moduleRtn=new Promise((a,c)=>{z=a;A=c});
+;return moduleRtn}export default Module;