@ikonai/sdk 0.0.36 → 0.0.38

package/assets/index-C-9F_--I.js

@@ -0,0 +1,186 @@
+let n = null, s = null;
+const h = 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 d() {
+  try {
+    return WebAssembly.validate(h);
+  } catch {
+    return !1;
+  }
+}
+async function m() {
+  return s || (n || (n = (async () => {
+    const r = await d();
+    let t;
+    r ? t = (await import("./libopus-simd-CQXMVirP.js")).default : t = (await import("./libopus-BBY7KH2-.js")).default;
+    const i = r ? "../wasm/libopus-simd.wasm" : "../wasm/libopus.wasm";
+    return s = await t({
+      locateFile: (e) => e.endsWith(".wasm") ? new URL(i, import.meta.url).href : e
+    }), s;
+  })()), n);
+}
+async function f() {
+  return d();
+}
+const p = 2048, u = 4002, a = 4010, _ = 4028, c = 4e3, l = 2880;
+class P {
+  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 ?? p, this.ready = this.initialize(t);
+  }
+  async initialize(t) {
+    this.module = await m();
+    const i = this.module._malloc(4);
+    this.encoder = this.module._opus_encoder_create(
+      this.sampleRate,
+      this.channels,
+      this.application,
+      i
+    );
+    const e = new DataView(this.module.HEAPU8.buffer).getInt32(i, !0);
+    if (this.module._free(i), e !== 0)
+      throw new Error(`opus_encoder_create failed with error code ${e}`);
+    this.setEncoderCtl(u, this.bitrate), t.complexity !== void 0 && this.setEncoderCtl(a, t.complexity), this.inputPtr = this.module._malloc(l * this.channels * 4), this.outputPtr = this.module._malloc(c);
+  }
+  setEncoderCtl(t, i) {
+    if (!this.module || !this.encoder)
+      return;
+    const e = this.module._malloc(4);
+    new DataView(this.module.HEAPU8.buffer).setInt32(e, i, !0), this.module._opus_encoder_ctl(this.encoder, t, e), this.module._free(e);
+  }
+  /**
+   * 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 i = t.length / this.channels;
+    if (i > l)
+      throw new Error(`Frame size too large: ${i} > ${l} samples`);
+    const e = this.inputPtr / 4;
+    this.module.HEAPF32.set(t, e);
+    const o = this.module._opus_encode_float(
+      this.encoder,
+      this.inputPtr,
+      i,
+      this.outputPtr,
+      c
+    );
+    if (o < 0)
+      throw new Error(`opus_encode_float failed with error code ${o}`);
+    return new Uint8Array(this.module.HEAPU8.buffer, this.outputPtr, o);
+  }
+  /**
+   * 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, _);
+  }
+  /**
+   * Set the encoder bitrate.
+   * @param bitrate - Target bitrate in bits per second
+   */
+  setBitrate(t) {
+    this.setEncoderCtl(u, t);
+  }
+  /**
+   * Set the encoder complexity (0-10, higher = better quality but more CPU).
+   * @param complexity - Complexity value (0-10)
+   */
+  setComplexity(t) {
+    this.setEncoderCtl(a, 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 {
+  c as MAX_PACKET_SIZE,
+  p as OPUS_APPLICATION_VOIP,
+  _ as OPUS_RESET_STATE,
+  u as OPUS_SET_BITRATE_REQUEST,
+  a as OPUS_SET_COMPLEXITY_REQUEST,
+  P as OpusEncoder,
+  m as getOpusModule,
+  f as isSimdSupported
+};

package/assets/index-C3ZAK5YF.js

@@ -0,0 +1,170 @@
+let a = null, i = null;
+const c = 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 u() {
+  try {
+    return WebAssembly.validate(c);
+  } catch {
+    return !1;
+  }
+}
+async function m() {
+  return i || (a || (a = (async () => {
+    const l = await u();
+    let e;
+    l ? e = (await import("./libopus-simd-CQXMVirP.js")).default : e = (await import("./libopus-BBY7KH2-.js")).default;
+    const t = l ? "../wasm/libopus-simd.wasm" : "../wasm/libopus.wasm";
+    return i = await e({
+      locateFile: (s) => s.endsWith(".wasm") ? new URL(t, import.meta.url).href : s
+    }), i;
+  })()), a);
+}
+const p = 4028, n = 5760, d = 4e3;
+class f {
+  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(n)), this.ready = this.initialize();
+  }
+  async initialize() {
+    this.module = await m();
+    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(d), this.outputPtr = this.module._malloc(n * 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 > d)
+      throw new Error(`Opus packet too large: ${e.length} > ${d}`);
+    this.module.HEAPU8.set(e, this.inputPtr);
+    const t = this.module._opus_decode_float(
+      this.decoder,
+      this.inputPtr,
+      e.length,
+      this.outputPtr,
+      n,
+      0
+      // decodeFec = false
+    );
+    if (t < 0)
+      throw new Error(`opus_decode_float failed with error code ${t}`);
+    const s = this.outputPtr / 4;
+    for (let r = 0; r < this.channels; r++) {
+      const h = this.channelBuffers[r];
+      for (let o = 0; o < t; o++)
+        h[o] = this.module.HEAPF32[s + o * this.channels + r];
+    }
+    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((s) => s.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, p);
+  }
+  /**
+   * 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 {
+  n as MAX_FRAME_SIZE,
+  d as MAX_PACKET_SIZE,
+  p as OPUS_RESET_STATE,
+  f as OpusDecoder,
+  m as getOpusModule
+};