@imcooder/opuslib 0.2.1 → 2.3.1

package/README.md

@@ -29,28 +29,37 @@
 >   });
 >   ```
 >
-> **New Fields**
-> - **`audioLevel`** — Each `audioChunk` event includes a normalized `audioLevel` (0.0~1.0), computed via configurable RMS sliding window (default 360ms) with dBFS-to-linear mapping (IEC 61606).
+> **`framesPerCallback` — batch multiple frames to reduce data transfer overhead**
+> - Multiple independently-encoded Opus frames can be batched into a single `audioChunk` callback via `framesPerCallback`, reducing JS bridge calls and data transfer overhead. Each frame in `frames[]` is a complete, independently decodable Opus packet (with its own TOC byte) — no illegal byte concatenation.
+> - Example: `frameSize=20ms, framesPerCallback=5` → 5 frames encoded individually, returned as `frames: OpusFrame[]` in one `audioChunk` event (80% fewer bridge calls).
+>
+> **New `audioChunk` fields**
+> - **`frames`** — Array of `OpusFrame` objects. Each frame is an independent, decodable Opus packet (with its own TOC byte). No illegal byte concatenation.
+> - **`OpusFrame.audioLevel`** — Per-frame normalized audio level (0.0~1.0), computed via RMS with dBFS-to-linear mapping. Only present when `enableAudioLevel: true`. Consumers can average neighboring frames for smoothing.
+> - **`duration`** — Duration of all frames in milliseconds (`frameSize * frameCount`).
+> - **`frameCount`** — Number of Opus frames in this callback (= `frames.length`).
+> - **`preSkip`** — (in `audioStarted` event) Opus encoder lookahead in samples. Decoders should skip this many samples at the beginning of the stream.
 >   ```typescript
 >   Opuslib.addListener('audioChunk', (event) => {
->     // event.data: ArrayBuffer            (Opus encoded packet)
+>     // event.frames: OpusFrame[]           (independent Opus packets)
+>     //   each frame: { data: ArrayBuffer, audioLevel?: number }
 >     // event.timestamp: 1711000000100     (ms since epoch)
->     // event.sequenceNumber: 5            (packet counter)
->     // event.audioLevel: 0.72            (0=silence, 1=loud)
+>     // event.sequenceNumber: 5            (callback counter)
+>     // event.duration: 100               (ms, = frameSize * frameCount)
+>     // event.frameCount: 5               (= frames.length)
 >   });
 >   ```
-> - **`preSkip`** — Opus encoder lookahead in samples, returned in `audioStarted` event. Decoders should skip this many samples at the beginning of the stream.
 >
 > **New Config Options**
-> - **`audioLevelWindow`** — RMS window duration in milliseconds for audio level calculation (default: 360ms). Shorter window = more responsive, longer window = smoother.
+> - **`enableAudioLevel`** — Enable per-frame audio level calculation (default: false). When enabled, each `OpusFrame` includes `audioLevel` (0.0~1.0). Disabled by default to save computation.
 >   ```typescript
 >   await Opuslib.startStreaming({
 >     sampleRate: 16000,
 >     channels: 1,
 >     bitrate: 24000,
 >     frameSize: 20,
->     packetDuration: 20,
->     audioLevelWindow: 200,  // 200ms window (default: 360ms)
+>     framesPerCallback: 5,  // batch 5 independent Opus frames per event
+>     enableAudioLevel: true, // enable per-frame audio level
 >   });
 >   ```
 
@@ -66,7 +75,7 @@ Real-time audio capture and encoding using the latest Opus 1.6 codec, built from
 - **Low Latency** - Real-time encoding with minimal overhead
 - **Native Performance** - Direct C/C++ integration, no JavaScript encoding
 - **Thread-safe Encoding** - Dedicated encoding thread, capture thread never blocked
-- **Audio Level Metering** - Real-time 0~1 audio level in each audio chunk (360ms RMS window)
+- **Audio Level Metering** - Optional per-frame 0~1 audio level via RMS (enable with `enableAudioLevel: true`)
 - **Lifecycle Events** - `audioStarted` / `audioEnd` events with session metadata
 - **High Quality** - 24kbps achieves excellent speech quality
 - **Cross-Platform** - iOS and Android with a consistent API
@@ -154,10 +163,11 @@ async function startRecording() {
 
   // Listen for encoded audio chunks
   const subscription = Opuslib.addListener('audioChunk', (event) => {
-    const { data, timestamp, sequenceNumber, audioLevel } = event;
-    console.log(`Opus packet: ${data.byteLength} bytes, level=${audioLevel.toFixed(2)}`);
-
-    // Send to your backend, save to file, etc.
+    const { frames, timestamp, sequenceNumber } = event;
+    for (const frame of frames) {
+      console.log(`Opus packet: ${frame.data.byteLength} bytes, level=${frame.audioLevel?.toFixed(2) ?? 'N/A'}`);
+      // Send each independent Opus packet to your backend, save to file, etc.
+    }
   });
 
   // Start streaming
@@ -166,7 +176,7 @@ async function startRecording() {
     channels: 1,            // Mono
     bitrate: 24000,         // 24 kbps
     frameSize: 20,          // 20ms frames
-    packetDuration: 20,     // 20ms packets
+    framesPerCallback: 1,   // 1 frame per callback (default)
   });
 }
 
@@ -194,9 +204,9 @@ interface AudioConfig {
   channels: number;                 // Number of channels (1 = mono, 2 = stereo)
   bitrate: number;                  // Target bitrate in bits/second (e.g., 24000)
   frameSize: number;                // Frame duration in ms (2.5, 5, 10, 20, 40, 60)
-  packetDuration: number;           // Packet duration in ms (multiple of frameSize)
+  framesPerCallback?: number;       // Frames per callback (default 1), batching reduces bridge calls
   dredDuration?: number;            // Reserved for future DRED support (default: 0)
-  audioLevelWindow?: number;        // RMS window duration in ms for audioLevel (default: 360)
+  enableAudioLevel?: boolean;       // Enable per-frame audio level (default: false)
   enableAmplitudeEvents?: boolean;  // Enable amplitude monitoring (default: false)
   amplitudeEventInterval?: number;  // Amplitude update interval in ms (default: 16)
 }
@@ -210,7 +220,7 @@ interface AudioConfig {
   channels: 1,           // Mono - sufficient for voice
   bitrate: 24000,        // 24 kbps - excellent quality
   frameSize: 20,         // 20ms - standard for real-time
-  packetDuration: 20,    // 20ms - low latency
+  framesPerCallback: 1,  // 1 frame per callback - low latency
 }
 ```
 
@@ -269,19 +279,30 @@ Emitted when an encoded Opus packet is ready.
 
 ```typescript
 Opuslib.addListener('audioChunk', (event: AudioChunkEvent) => {
-  // event.data: ArrayBuffer - Raw Opus packet (ready to send/save)
-  // event.audioLevel: number - Audio level 0.0~1.0 (0=silence, 1=loud)
+  // event.frames: OpusFrame[] - Independent Opus packets (each decodable on its own)
+  //   frame.audioLevel?: number - Per-frame level 0.0~1.0 (when enableAudioLevel is true)
+  // event.duration: number - Duration in ms (frameSize * frameCount)
+  // event.frameCount: number - Number of Opus frames (= frames.length)
+  for (const frame of event.frames) {
+    websocket.send(frame.data);  // each frame is an independent Opus packet
+  }
 });
 ```
 
 **Event Data:**
 
 ```typescript
+interface OpusFrame {
+  data: ArrayBuffer;         // Independent Opus packet (one opus_encode() output with its own TOC byte)
+  audioLevel?: number;       // Per-frame audio level 0.0~1.0 (only when enableAudioLevel is true)
+}
+
 interface AudioChunkEvent {
-  data: ArrayBuffer;         // Raw Opus-encoded audio packet
+  frames: OpusFrame[];       // Array of independent Opus packets
   timestamp: number;         // Milliseconds since epoch
-  sequenceNumber: number;    // Incrementing packet counter
-  audioLevel: number;        // Audio level 0.0~1.0 (360ms RMS window, 0=silence, 1=loud)
+  sequenceNumber: number;    // Incrementing callback counter
+  duration: number;          // Total duration in ms (frameSize * frameCount)
+  frameCount: number;        // Number of Opus frames (= frames.length)
 }
 ```
 
@@ -347,7 +368,7 @@ Capture Thread                  Encoding Thread (serial queue)
   |---- post(samples) ----------->| pendingSamples.append(samples)
   |                               | while (enough samples) {
   |                               |   opus_encode()
-  |                               |   audioLevel calc (360ms RMS)
+  |                               |   per-frame audioLevel (if enabled)
   |                               |   emit audioChunk event
   |                               | }
   |                               |

package/android/src/main/java/expo/modules/opuslib/AudioProcessor.kt

@@ -7,6 +7,14 @@ import java.io.File
 import java.io.FileOutputStream
 import java.util.concurrent.CountDownLatch
 
+/**
+ * A single encoded Opus frame with optional per-frame audio level.
+ */
+data class EncodedFrame(
+  val data: ByteArray,
+  val audioLevel: Float?  // null when enableAudioLevel is false
+)
+
 /**
  * AudioProcessor - Dedicated encoding thread for Opus encoding and dispatch.
  *
@@ -31,20 +39,20 @@ class AudioProcessor(private val config: AudioConfig) {
   private var opusEncoder: OpusEncoder? = null
   private val pendingSamples = mutableListOf<Short>()
   private val samplesPerFrame: Int = (config.sampleRate * config.frameSize / 1000.0).toInt()
+  private val framesPerPacket: Int = Math.max(1, config.framesPerCallback)
+  private var packetFrames = mutableListOf<EncodedFrame>()  // independent Opus packets with per-frame level
   private var sequenceNumber: Int = 0
   private var startTime: Double = 0.0
 
-  // Audio level: accumulate RMS over ~360ms window
-  private var levelSumSquares: Double = 0.0
-  private var levelSampleCount: Int = 0
-  private val levelUpdateSamples: Int = config.sampleRate * config.channels * config.audioLevelWindow / 1000
-  private var currentLevel: Float = 0.0f
+  // Whether to compute per-frame audio level
+  private val enableAudioLevel: Boolean = config.enableAudioLevel
 
   // Debug file output
   private var pcmFileOutputStream: FileOutputStream? = null
 
   // Event callbacks (all invoked on encoding thread)
-  private var onAudioChunk: ((ByteArray, Double, Int, Float) -> Unit)? = null
+  // onAudioChunk: (frames, timestamp, sequenceNumber, duration, frameCount)
+  private var onAudioChunk: ((List<EncodedFrame>, Double, Int, Double, Int) -> Unit)? = null
   private var onStarted: ((timestamp: Double, sampleRate: Int, channels: Int, bitrate: Int, frameSize: Double, preSkip: Int) -> Unit)? = null
   private var onEnd: ((timestamp: Double, totalDuration: Double, totalPackets: Int) -> Unit)? = null
 
@@ -138,7 +146,7 @@ class AudioProcessor(private val config: AudioConfig) {
 
   // MARK: - Event callback setters
 
-  fun setOnAudioChunk(callback: (ByteArray, Double, Int, Float) -> Unit) {
+  fun setOnAudioChunk(callback: (List<EncodedFrame>, Double, Int, Double, Int) -> Unit) {
     this.onAudioChunk = callback
   }
 
@@ -179,6 +187,7 @@ class AudioProcessor(private val config: AudioConfig) {
         fos.write(bytes)
       }
 
+      // Encode single frame to Opus
       val opusData = try {
         encoder.encode(frameData, samplesPerFrame)
       } catch (e: Exception) {
@@ -191,37 +200,47 @@ class AudioProcessor(private val config: AudioConfig) {
         continue
       }
 
-      // Accumulate energy for RMS over ~360ms window
-      for (sample in frameData) {
-        val s = sample.toDouble() / 32768.0
-        levelSumSquares += s * s
-      }
-      levelSampleCount += frameData.size
-
-      if (levelSampleCount >= levelUpdateSamples) {
-        val rms = Math.sqrt(levelSumSquares / levelSampleCount)
+      // Per-frame audio level (RMS → dBFS → 0~1)
+      var frameLevel: Float? = null
+      if (enableAudioLevel) {
+        var sumSquares = 0.0
+        for (sample in frameData) {
+          val s = sample.toDouble() / 32768.0
+          sumSquares += s * s
+        }
+        val rms = Math.sqrt(sumSquares / frameData.size)
         val dB = 20.0 * Math.log10(Math.max(rms, 1e-10))
         val dbFloor = -35.0
         val dbCeiling = -6.0
-        currentLevel = Math.max(0.0, Math.min(1.0, (dB - dbFloor) / (dbCeiling - dbFloor))).toFloat()
-        levelSumSquares = 0.0
-        levelSampleCount = 0
+        frameLevel = Math.max(0.0, Math.min(1.0, (dB - dbFloor) / (dbCeiling - dbFloor))).toFloat()
       }
 
-      val timestampMs = System.currentTimeMillis().toDouble()
-      onAudioChunk?.invoke(opusData, timestampMs, sequenceNumber, currentLevel)
-      sequenceNumber++
+      // Accumulate encoded frame as independent packet (no byte concatenation)
+      packetFrames.add(EncodedFrame(data = opusData, audioLevel = frameLevel))
+
+      // Emit when we have enough frames (framesPerCallback)
+      if (packetFrames.size >= framesPerPacket) {
+        val timestampMs = System.currentTimeMillis().toDouble()
+        val frameCount = packetFrames.size
+        val duration = frameCount * config.frameSize
+        onAudioChunk?.invoke(packetFrames.toList(), timestampMs, sequenceNumber, duration, frameCount)
+        sequenceNumber++
+        packetFrames.clear()
+      }
     }
   }
 
   private fun _flushRemainingFrames() {
     val encoder = opusEncoder ?: return
-    if (pendingSamples.isEmpty()) return
 
-    while (pendingSamples.size < samplesPerFrame) {
-      pendingSamples.add(0)
+    // Pad remaining PCM with silence to fill the last frame
+    if (pendingSamples.isNotEmpty() && pendingSamples.size < samplesPerFrame) {
+      while (pendingSamples.size < samplesPerFrame) {
+        pendingSamples.add(0)
+      }
     }
 
+    // Encode remaining frames
     while (pendingSamples.size >= samplesPerFrame) {
       val frameData = ShortArray(samplesPerFrame)
       for (i in 0 until samplesPerFrame) {
@@ -235,10 +254,18 @@ class AudioProcessor(private val config: AudioConfig) {
       }
 
       if (opusData == null || opusData.isEmpty()) continue
+      // Flush frames get level 0 (silence-padded)
+      packetFrames.add(EncodedFrame(data = opusData, audioLevel = if (enableAudioLevel) 0.0f else null))
+    }
 
+    // Flush any remaining frames (even if less than framesPerPacket)
+    if (packetFrames.isNotEmpty()) {
       val timestampMs = System.currentTimeMillis().toDouble()
-      onAudioChunk?.invoke(opusData, timestampMs, sequenceNumber, currentLevel)
+      val frameCount = packetFrames.size
+      val duration = frameCount * config.frameSize
+      onAudioChunk?.invoke(packetFrames.toList(), timestampMs, sequenceNumber, duration, frameCount)
       sequenceNumber++
+      packetFrames.clear()
     }
   }
 }

package/android/src/main/java/expo/modules/opuslib/AudioRecordManager.kt

@@ -37,7 +37,7 @@ class AudioRecordManager(
   private var loggedFirstBuffer = false
 
   // Event callbacks
-  private var onAudioChunk: ((ByteArray, Double, Int, Float) -> Unit)? = null
+  private var onAudioChunk: ((List<EncodedFrame>, Double, Int, Double, Int) -> Unit)? = null
   private var onStarted: ((timestamp: Double, sampleRate: Int, channels: Int, bitrate: Int, frameSize: Double, preSkip: Int) -> Unit)? = null
   private var onEnd: ((timestamp: Double, totalDuration: Double, totalPackets: Int) -> Unit)? = null
   private var onAmplitude: ((Float, Float, Double) -> Unit)? = null
@@ -91,8 +91,8 @@ class AudioRecordManager(
 
     // Create and start AudioProcessor (encoding thread)
     val proc = AudioProcessor(config)
-    proc.setOnAudioChunk { data, timestamp, seq, level ->
-      onAudioChunk?.invoke(data, timestamp, seq, level)
+    proc.setOnAudioChunk { frames, timestamp, seq, duration, frameCount ->
+      onAudioChunk?.invoke(frames, timestamp, seq, duration, frameCount)
     }
     proc.setOnStarted { timestamp, sampleRate, channels, bitrate, frameSize, preSkip ->
       onStarted?.invoke(timestamp, sampleRate, channels, bitrate, frameSize, preSkip)
@@ -172,7 +172,7 @@ class AudioRecordManager(
   }
 
   // Event handlers
-  fun setOnAudioChunk(callback: (ByteArray, Double, Int, Float) -> Unit) {
+  fun setOnAudioChunk(callback: (List<EncodedFrame>, Double, Int, Double, Int) -> Unit) {
     this.onAudioChunk = callback
   }
 

package/android/src/main/java/expo/modules/opuslib/OpuslibModule.kt

@@ -81,12 +81,19 @@ class OpuslibModule : Module() {
 
     // Set up event callbacks — audioStarted/audioEnd come from encoding thread
     android.util.Log.d(TAG, "🔗 Setting up event callbacks...")
-    manager.setOnAudioChunk { data, timestamp, sequenceNumber, audioLevel ->
+    manager.setOnAudioChunk { frames, timestamp, sequenceNumber, duration, frameCount ->
+      // Each frame is an independent Opus packet wrapped in { data, audioLevel? }
+      val frameObjects = frames.map { frame ->
+        val obj = mutableMapOf<String, Any>("data" to frame.data)
+        frame.audioLevel?.let { obj["audioLevel"] = it }
+        obj
+      }
       sendEvent("audioChunk", mapOf(
-        "data" to data,
+        "frames" to frameObjects,
         "timestamp" to timestamp,
         "sequenceNumber" to sequenceNumber,
-        "audioLevel" to audioLevel
+        "duration" to duration,
+        "frameCount" to frameCount
       ))
     }
 
@@ -191,7 +198,7 @@ class AudioConfig : Record {
   var frameSize: Double = 20.0
 
   @Field
-  var packetDuration: Double = 20.0
+  var framesPerCallback: Int = 1
 
   @Field
   var dredDuration: Int = 100  // NEW: DRED recovery duration in ms
@@ -203,7 +210,7 @@ class AudioConfig : Record {
   var amplitudeEventInterval: Double = 16.0
 
   @Field
-  var audioLevelWindow: Int = 360  // RMS window duration in ms (default 360)
+  var enableAudioLevel: Boolean = false  // Enable per-frame audio level calculation
 
   @Field
   var saveDebugAudio: Boolean = false

package/build/Opuslib.types.d.ts

@@ -10,31 +10,42 @@ export interface AudioConfig {
     bitrate: number;
     /** Frame duration in milliseconds (2.5, 5, 10, 20, 40, 60) */
     frameSize: number;
-    /** Packet duration in milliseconds (typically 20-100ms) */
-    packetDuration: number;
+    /** Number of Opus frames per callback (default 1). Multiple frames are returned as independent packets in frames[], reducing JS bridge calls */
+    framesPerCallback?: number;
     /** DRED recovery duration in milliseconds (0-100, default 100) - NEW in Opus 1.6 */
     dredDuration?: number;
     /** Enable amplitude events for waveform visualization */
     enableAmplitudeEvents?: boolean;
     /** Amplitude event interval in milliseconds (default 16) */
     amplitudeEventInterval?: number;
-    /** Audio level RMS window duration in milliseconds (default 360) */
-    audioLevelWindow?: number;
+    /** Enable per-frame audio level calculation (default false). When enabled, each OpusFrame includes audioLevel */
+    enableAudioLevel?: boolean;
     /** Save debug PCM audio to file (development only) */
     saveDebugAudio?: boolean;
 }
+/**
+ * A single Opus frame — one complete opus_encode() output with its own TOC byte
+ */
+export interface OpusFrame {
+    /** Opus-encoded packet data (independent, decodable) */
+    data: ArrayBuffer;
+    /** Per-frame audio level 0.0~1.0 (only present when enableAudioLevel is true) */
+    audioLevel?: number;
+}
 /**
  * Audio chunk event payload (Opus-encoded data)
  */
 export interface AudioChunkEvent {
-    /** Opus-encoded audio data as ArrayBuffer */
-    data: ArrayBuffer;
+    /** Array of independent Opus frames. Each frame is a complete opus_encode() output, decodable on its own */
+    frames: OpusFrame[];
     /** Timestamp in milliseconds */
     timestamp: number;
-    /** Sequence number (increments with each packet) */
+    /** Sequence number (increments with each callback) */
     sequenceNumber: number;
-    /** Audio level normalized to 0.0~1.0 (mapped from dBFS, 0 = silence, 1 = loud) */
-    audioLevel: number;
+    /** Duration of all frames in milliseconds (frameSize * frameCount) */
+    duration: number;
+    /** Number of Opus frames in this callback (= frames.length) */
+    frameCount: number;
 }
 /**
  * Amplitude event payload (for waveform visualization)

package/build/Opuslib.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Opuslib.types.d.ts","sourceRoot":"","sources":["../src/Opuslib.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAA;IACf,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAA;IACtB,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,4DAA4D;IAC5D,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,oEAAoE;IACpE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,sDAAsD;IACtD,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,IAAI,EAAE,WAAW,CAAA;IACjB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAA;IACtB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAA;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAA;IACjB,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB"}
+{"version":3,"file":"Opuslib.types.d.ts","sourceRoot":"","sources":["../src/Opuslib.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAA;IACf,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,gJAAgJ;IAChJ,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,4DAA4D;IAC5D,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,iHAAiH;IACjH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,sDAAsD;IACtD,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,IAAI,EAAE,WAAW,CAAA;IACjB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,4GAA4G;IAC5G,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAA;IAChB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAA;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAA;IACjB,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB"}

package/build/Opuslib.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"Opuslib.types.js","sourceRoot":"","sources":["../src/Opuslib.types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Audio configuration for Opus encoding\n */\nexport interface AudioConfig {\n  /** Sample rate in Hz (8000, 12000, 16000, 24000, 48000) */\n  sampleRate: number\n  /** Number of channels (1 = mono, 2 = stereo) */\n  channels: number\n  /** Target bitrate in bits/second (e.g., 24000 for 24kbps) */\n  bitrate: number\n  /** Frame duration in milliseconds (2.5, 5, 10, 20, 40, 60) */\n  frameSize: number\n  /** Packet duration in milliseconds (typically 20-100ms) */\n  packetDuration: number\n  /** DRED recovery duration in milliseconds (0-100, default 100) - NEW in Opus 1.6 */\n  dredDuration?: number\n  /** Enable amplitude events for waveform visualization */\n  enableAmplitudeEvents?: boolean\n  /** Amplitude event interval in milliseconds (default 16) */\n  amplitudeEventInterval?: number\n  /** Audio level RMS window duration in milliseconds (default 360) */\n  audioLevelWindow?: number\n  /** Save debug PCM audio to file (development only) */\n  saveDebugAudio?: boolean\n}\n\n/**\n * Audio chunk event payload (Opus-encoded data)\n */\nexport interface AudioChunkEvent {\n  /** Opus-encoded audio data as ArrayBuffer */\n  data: ArrayBuffer\n  /** Timestamp in milliseconds */\n  timestamp: number\n  /** Sequence number (increments with each packet) */\n  sequenceNumber: number\n  /** Audio level normalized to 0.0~1.0 (mapped from dBFS, 0 = silence, 1 = loud) */\n  audioLevel: number\n}\n\n/**\n * Amplitude event payload (for waveform visualization)\n */\nexport interface AmplitudeEvent {\n  /** Root mean square amplitude (0.0 - 1.0) */\n  rms: number\n  /** Peak amplitude (0.0 - 1.0) */\n  peak: number\n  /** Timestamp in milliseconds */\n  timestamp: number\n}\n\n/**\n * Audio started event payload\n * Emitted when audio streaming successfully starts\n */\nexport interface AudioStartedEvent {\n  /** Timestamp in milliseconds when streaming started */\n  timestamp: number\n  /** Actual sample rate being used */\n  sampleRate: number\n  /** Number of channels */\n  channels: number\n  /** Configured bitrate in bits/second */\n  bitrate: number\n  /** Frame duration in milliseconds */\n  frameSize: number\n  /** Opus encoder lookahead in samples (decoder should skip this many samples at start) */\n  preSkip: number\n}\n\n/**\n * Audio end event payload\n * Emitted when audio streaming stops\n */\nexport interface AudioEndEvent {\n  /** Timestamp in milliseconds when streaming stopped */\n  timestamp: number\n  /** Total duration of the streaming session in milliseconds */\n  totalDuration: number\n  /** Total number of packets encoded during the session */\n  totalPackets: number\n}\n\n/**\n * Error event payload\n */\nexport interface ErrorEvent {\n  /** Error code */\n  code: string\n  /** Error message */\n  message: string\n}\n\n/**\n * Event subscription\n */\nexport interface Subscription {\n  remove: () => void\n}\n"]}
+{"version":3,"file":"Opuslib.types.js","sourceRoot":"","sources":["../src/Opuslib.types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Audio configuration for Opus encoding\n */\nexport interface AudioConfig {\n  /** Sample rate in Hz (8000, 12000, 16000, 24000, 48000) */\n  sampleRate: number\n  /** Number of channels (1 = mono, 2 = stereo) */\n  channels: number\n  /** Target bitrate in bits/second (e.g., 24000 for 24kbps) */\n  bitrate: number\n  /** Frame duration in milliseconds (2.5, 5, 10, 20, 40, 60) */\n  frameSize: number\n  /** Number of Opus frames per callback (default 1). Multiple frames are returned as independent packets in frames[], reducing JS bridge calls */\n  framesPerCallback?: number\n  /** DRED recovery duration in milliseconds (0-100, default 100) - NEW in Opus 1.6 */\n  dredDuration?: number\n  /** Enable amplitude events for waveform visualization */\n  enableAmplitudeEvents?: boolean\n  /** Amplitude event interval in milliseconds (default 16) */\n  amplitudeEventInterval?: number\n  /** Enable per-frame audio level calculation (default false). When enabled, each OpusFrame includes audioLevel */\n  enableAudioLevel?: boolean\n  /** Save debug PCM audio to file (development only) */\n  saveDebugAudio?: boolean\n}\n\n/**\n * A single Opus frame — one complete opus_encode() output with its own TOC byte\n */\nexport interface OpusFrame {\n  /** Opus-encoded packet data (independent, decodable) */\n  data: ArrayBuffer\n  /** Per-frame audio level 0.0~1.0 (only present when enableAudioLevel is true) */\n  audioLevel?: number\n}\n\n/**\n * Audio chunk event payload (Opus-encoded data)\n */\nexport interface AudioChunkEvent {\n  /** Array of independent Opus frames. Each frame is a complete opus_encode() output, decodable on its own */\n  frames: OpusFrame[]\n  /** Timestamp in milliseconds */\n  timestamp: number\n  /** Sequence number (increments with each callback) */\n  sequenceNumber: number\n  /** Duration of all frames in milliseconds (frameSize * frameCount) */\n  duration: number\n  /** Number of Opus frames in this callback (= frames.length) */\n  frameCount: number\n}\n\n/**\n * Amplitude event payload (for waveform visualization)\n */\nexport interface AmplitudeEvent {\n  /** Root mean square amplitude (0.0 - 1.0) */\n  rms: number\n  /** Peak amplitude (0.0 - 1.0) */\n  peak: number\n  /** Timestamp in milliseconds */\n  timestamp: number\n}\n\n/**\n * Audio started event payload\n * Emitted when audio streaming successfully starts\n */\nexport interface AudioStartedEvent {\n  /** Timestamp in milliseconds when streaming started */\n  timestamp: number\n  /** Actual sample rate being used */\n  sampleRate: number\n  /** Number of channels */\n  channels: number\n  /** Configured bitrate in bits/second */\n  bitrate: number\n  /** Frame duration in milliseconds */\n  frameSize: number\n  /** Opus encoder lookahead in samples (decoder should skip this many samples at start) */\n  preSkip: number\n}\n\n/**\n * Audio end event payload\n * Emitted when audio streaming stops\n */\nexport interface AudioEndEvent {\n  /** Timestamp in milliseconds when streaming stopped */\n  timestamp: number\n  /** Total duration of the streaming session in milliseconds */\n  totalDuration: number\n  /** Total number of packets encoded during the session */\n  totalPackets: number\n}\n\n/**\n * Error event payload\n */\nexport interface ErrorEvent {\n  /** Error code */\n  code: string\n  /** Error message */\n  message: string\n}\n\n/**\n * Event subscription\n */\nexport interface Subscription {\n  remove: () => void\n}\n"]}

package/build/OpuslibModule.d.ts

@@ -17,7 +17,7 @@ declare const _default: {
      *   channels: 1,
      *   bitrate: 24000,
      *   frameSize: 20,
-     *   packetDuration: 20,
+     *   framesPerCallback: 5, // batch 5 independent Opus packets per event
      *   dredDuration: 100, // Enable 100ms DRED recovery
      * })
      * ```
@@ -45,8 +45,10 @@ declare const _default: {
      * ```ts
      * // Listen for audio chunks
      * const subscription = Opuslib.addListener('audioChunk', (event) => {
-     *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')
-     *   websocket.send(event.data)
+     *   for (const frame of event.frames) {
+     *     console.log('Opus packet:', frame.data.byteLength, 'bytes')
+     *     websocket.send(frame.data)
+     *   }
      * })
      *
      * // Listen for errors

package/build/OpuslibModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAoC/I;;;;;GAKG;;IAED;;;;;;;;;;;;;;;OAeG;6BACsB,WAAW;IAEpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;iBAIsE;QACvE,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,YAAY,CAAA;QACnF,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,YAAY,CAAA;QACjF,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,YAAY,CAAA;QACvF,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,YAAY,CAAA;QAC/E,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,YAAY,CAAA;KAC1E;IAED;;;;;OAKG;qCAES,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KACxC,YAAY;IAEf;;;;;OAKG;iCAES,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,KACpC,YAAY;;AAvFjB,wBAwFC"}
+{"version":3,"file":"OpuslibModule.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAoC/I;;;;;GAKG;;IAED;;;;;;;;;;;;;;;OAeG;6BACsB,WAAW;IAEpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;iBAIsE;QACvE,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,YAAY,CAAA;QACnF,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,YAAY,CAAA;QACjF,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAAG,YAAY,CAAA;QACvF,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,YAAY,CAAA;QAC/E,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,YAAY,CAAA;KAC1E;IAED;;;;;OAKG;qCAES,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KACxC,YAAY;IAEf;;;;;OAKG;iCAES,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,KACpC,YAAY;;AAzFjB,wBA0FC"}

package/build/OpuslibModule.js

@@ -21,7 +21,7 @@ export default {
      *   channels: 1,
      *   bitrate: 24000,
      *   frameSize: 20,
-     *   packetDuration: 20,
+     *   framesPerCallback: 5, // batch 5 independent Opus packets per event
      *   dredDuration: 100, // Enable 100ms DRED recovery
      * })
      * ```
@@ -49,8 +49,10 @@ export default {
      * ```ts
      * // Listen for audio chunks
      * const subscription = Opuslib.addListener('audioChunk', (event) => {
-     *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')
-     *   websocket.send(event.data)
+     *   for (const frame of event.frames) {
+     *     console.log('Opus packet:', frame.data.byteLength, 'bytes')
+     *     websocket.send(frame.data)
+     *   }
      * })
      *
      * // Listen for errors

package/build/OpuslibModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.js","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AA+BtE,kCAAkC;AAClC,MAAM,aAAa,GAAG,mBAAmB,CAAoB,SAAS,CAAC,CAAA;AAEvE,+CAA+C;AAC/C,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,aAAoB,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAe;IACb;;;;;;;;;;;;;;;OAeG;IACH,cAAc,EAAE,CAAC,MAAmB,EAAE,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC;IAE7E;;OAEG;IACH,aAAa,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;IAElD;;OAEG;IACH,cAAc,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE;IAEpD;;OAEG;IACH,eAAe,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,eAAe,EAAE;IAEtD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,EAAE,CAAC,CACZ,SAA6E,EAC7E,QAA4G,EAC9F,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAMnE;IAED;;;;;OAKG;IACH,oBAAoB,EAAE,CACpB,QAAyC,EAC3B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC;IAEtE;;;;;OAKG;IACH,gBAAgB,EAAE,CAChB,QAAqC,EACvB,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC;CACnE,CAAA","sourcesContent":["import { NativeModule, requireNativeModule, EventEmitter } from 'expo'\nimport type { AudioConfig, AudioChunkEvent, AmplitudeEvent, AudioStartedEvent, AudioEndEvent, ErrorEvent, Subscription } from './Opuslib.types'\n\n/**\n * Opuslib Native Module Interface\n *\n * Provides native audio capture and Opus 1.6 encoding with DRED support\n */\ndeclare class OpuslibModuleType extends NativeModule {\n  /**\n   * Start audio streaming with Opus encoding\n   * @param config Audio configuration\n   */\n  startStreaming(config: AudioConfig): Promise<void>\n\n  /**\n   * Stop audio streaming\n   */\n  stopStreaming(): Promise<void>\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming(): void\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming(): void\n}\n\n// Load the native module from JSI\nconst OpuslibModule = requireNativeModule<OpuslibModuleType>('Opuslib')\n\n// Create event emitter for listening to events\nconst emitter = new EventEmitter(OpuslibModule as any)\n\n/**\n * Opuslib - Opus 1.6 Audio Encoding with DRED Support\n *\n * This module provides real-time audio capture and Opus 1.6 encoding\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n */\nexport default {\n  /**\n   * Start audio streaming with Opus encoding\n   *\n   * @param config Audio configuration\n   * @example\n   * ```ts\n   * await Opuslib.startStreaming({\n   *   sampleRate: 16000,\n   *   channels: 1,\n   *   bitrate: 24000,\n   *   frameSize: 20,\n   *   packetDuration: 20,\n   *   dredDuration: 100, // Enable 100ms DRED recovery\n   * })\n   * ```\n   */\n  startStreaming: (config: AudioConfig) => OpuslibModule.startStreaming(config),\n\n  /**\n   * Stop audio streaming and release resources\n   */\n  stopStreaming: () => OpuslibModule.stopStreaming(),\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming: () => OpuslibModule.pauseStreaming(),\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming: () => OpuslibModule.resumeStreaming(),\n\n  /**\n   * Listen for events (audioChunk, amplitude, or error)\n   *\n   * @param eventName Event type to listen for\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   * @example\n   * ```ts\n   * // Listen for audio chunks\n   * const subscription = Opuslib.addListener('audioChunk', (event) => {\n   *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')\n   *   websocket.send(event.data)\n   * })\n   *\n   * // Listen for errors\n   * const errorSub = Opuslib.addListener('error', (event) => {\n   *   console.error('Error:', event.message)\n   * })\n   *\n   * // Later: unsubscribe\n   * subscription.remove()\n   * errorSub.remove()\n   * ```\n   */\n  addListener: ((\n    eventName: 'audioChunk' | 'amplitude' | 'audioStarted' | 'audioEnd' | 'error',\n    listener: (event: AudioChunkEvent | AmplitudeEvent | AudioStartedEvent | AudioEndEvent | ErrorEvent) => void\n  ): Subscription => (emitter as any).addListener(eventName, listener)) as {\n    (eventName: 'audioChunk', listener: (event: AudioChunkEvent) => void): Subscription\n    (eventName: 'amplitude', listener: (event: AmplitudeEvent) => void): Subscription\n    (eventName: 'audioStarted', listener: (event: AudioStartedEvent) => void): Subscription\n    (eventName: 'audioEnd', listener: (event: AudioEndEvent) => void): Subscription\n    (eventName: 'error', listener: (event: ErrorEvent) => void): Subscription\n  },\n\n  /**\n   * Listen for amplitude events (for waveform visualization)\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAmplitudeListener: (\n    listener: (event: AmplitudeEvent) => void\n  ): Subscription => (emitter as any).addListener('amplitude', listener),\n\n  /**\n   * Listen for error events\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addErrorListener: (\n    listener: (event: ErrorEvent) => void\n  ): Subscription => (emitter as any).addListener('error', listener),\n}\n"]}
+{"version":3,"file":"OpuslibModule.js","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AA+BtE,kCAAkC;AAClC,MAAM,aAAa,GAAG,mBAAmB,CAAoB,SAAS,CAAC,CAAA;AAEvE,+CAA+C;AAC/C,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,aAAoB,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAe;IACb;;;;;;;;;;;;;;;OAeG;IACH,cAAc,EAAE,CAAC,MAAmB,EAAE,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC;IAE7E;;OAEG;IACH,aAAa,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;IAElD;;OAEG;IACH,cAAc,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE;IAEpD;;OAEG;IACH,eAAe,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,eAAe,EAAE;IAEtD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CACZ,SAA6E,EAC7E,QAA4G,EAC9F,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAMnE;IAED;;;;;OAKG;IACH,oBAAoB,EAAE,CACpB,QAAyC,EAC3B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC;IAEtE;;;;;OAKG;IACH,gBAAgB,EAAE,CAChB,QAAqC,EACvB,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC;CACnE,CAAA","sourcesContent":["import { NativeModule, requireNativeModule, EventEmitter } from 'expo'\nimport type { AudioConfig, AudioChunkEvent, AmplitudeEvent, AudioStartedEvent, AudioEndEvent, ErrorEvent, Subscription } from './Opuslib.types'\n\n/**\n * Opuslib Native Module Interface\n *\n * Provides native audio capture and Opus 1.6 encoding with DRED support\n */\ndeclare class OpuslibModuleType extends NativeModule {\n  /**\n   * Start audio streaming with Opus encoding\n   * @param config Audio configuration\n   */\n  startStreaming(config: AudioConfig): Promise<void>\n\n  /**\n   * Stop audio streaming\n   */\n  stopStreaming(): Promise<void>\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming(): void\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming(): void\n}\n\n// Load the native module from JSI\nconst OpuslibModule = requireNativeModule<OpuslibModuleType>('Opuslib')\n\n// Create event emitter for listening to events\nconst emitter = new EventEmitter(OpuslibModule as any)\n\n/**\n * Opuslib - Opus 1.6 Audio Encoding with DRED Support\n *\n * This module provides real-time audio capture and Opus 1.6 encoding\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n */\nexport default {\n  /**\n   * Start audio streaming with Opus encoding\n   *\n   * @param config Audio configuration\n   * @example\n   * ```ts\n   * await Opuslib.startStreaming({\n   *   sampleRate: 16000,\n   *   channels: 1,\n   *   bitrate: 24000,\n   *   frameSize: 20,\n   *   framesPerCallback: 5, // batch 5 independent Opus packets per event\n   *   dredDuration: 100, // Enable 100ms DRED recovery\n   * })\n   * ```\n   */\n  startStreaming: (config: AudioConfig) => OpuslibModule.startStreaming(config),\n\n  /**\n   * Stop audio streaming and release resources\n   */\n  stopStreaming: () => OpuslibModule.stopStreaming(),\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming: () => OpuslibModule.pauseStreaming(),\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming: () => OpuslibModule.resumeStreaming(),\n\n  /**\n   * Listen for events (audioChunk, amplitude, or error)\n   *\n   * @param eventName Event type to listen for\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   * @example\n   * ```ts\n   * // Listen for audio chunks\n   * const subscription = Opuslib.addListener('audioChunk', (event) => {\n   *   for (const frame of event.frames) {\n   *     console.log('Opus packet:', frame.data.byteLength, 'bytes')\n   *     websocket.send(frame.data)\n   *   }\n   * })\n   *\n   * // Listen for errors\n   * const errorSub = Opuslib.addListener('error', (event) => {\n   *   console.error('Error:', event.message)\n   * })\n   *\n   * // Later: unsubscribe\n   * subscription.remove()\n   * errorSub.remove()\n   * ```\n   */\n  addListener: ((\n    eventName: 'audioChunk' | 'amplitude' | 'audioStarted' | 'audioEnd' | 'error',\n    listener: (event: AudioChunkEvent | AmplitudeEvent | AudioStartedEvent | AudioEndEvent | ErrorEvent) => void\n  ): Subscription => (emitter as any).addListener(eventName, listener)) as {\n    (eventName: 'audioChunk', listener: (event: AudioChunkEvent) => void): Subscription\n    (eventName: 'amplitude', listener: (event: AmplitudeEvent) => void): Subscription\n    (eventName: 'audioStarted', listener: (event: AudioStartedEvent) => void): Subscription\n    (eventName: 'audioEnd', listener: (event: AudioEndEvent) => void): Subscription\n    (eventName: 'error', listener: (event: ErrorEvent) => void): Subscription\n  },\n\n  /**\n   * Listen for amplitude events (for waveform visualization)\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAmplitudeListener: (\n    listener: (event: AmplitudeEvent) => void\n  ): Subscription => (emitter as any).addListener('amplitude', listener),\n\n  /**\n   * Listen for error events\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addErrorListener: (\n    listener: (event: ErrorEvent) => void\n  ): Subscription => (emitter as any).addListener('error', listener),\n}\n"]}

package/build/index.d.ts

@@ -14,14 +14,15 @@
  *   channels: 1,
  *   bitrate: 24000,
  *   frameSize: 20,
- *   packetDuration: 20,
+ *   framesPerCallback: 5, // batch 5 independent Opus frames per event
  *   dredDuration: 100, // 100ms DRED recovery
  * })
  *
  * // Listen for Opus packets
  * Opuslib.addListener('audioChunk', (event) => {
- *   // Send to backend
- *   websocket.send(event.data)
+ *   for (const frame of event.frames) {
+ *     websocket.send(frame.data)
+ *   }
  * })
  *
  * // Stop streaming

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,cAAc,iBAAiB,CAAA"}

package/build/index.js

@@ -14,14 +14,15 @@
  *   channels: 1,
  *   bitrate: 24000,
  *   frameSize: 20,
- *   packetDuration: 20,
+ *   framesPerCallback: 5, // batch 5 independent Opus frames per event
  *   dredDuration: 100, // 100ms DRED recovery
  * })
  *
  * // Listen for Opus packets
  * Opuslib.addListener('audioChunk', (event) => {
- *   // Send to backend
- *   websocket.send(event.data)
+ *   for (const frame of event.frames) {
+ *     websocket.send(frame.data)
+ *   }
  * })
  *
  * // Stop streaming

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,cAAc,iBAAiB,CAAA","sourcesContent":["/**\n * Opuslib - Opus 1.6 Audio Encoding with DRED Support\n *\n * Native audio capture and Opus 1.6 encoding for React Native/Expo\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n *\n * @example\n * ```ts\n * import Opuslib from 'opuslib'\n *\n * // Start streaming with DRED enabled\n * await Opuslib.startStreaming({\n *   sampleRate: 16000,\n *   channels: 1,\n *   bitrate: 24000,\n *   frameSize: 20,\n *   packetDuration: 20,\n *   dredDuration: 100, // 100ms DRED recovery\n * })\n *\n * // Listen for Opus packets\n * Opuslib.addListener('audioChunk', (event) => {\n *   // Send to backend\n *   websocket.send(event.data)\n * })\n *\n * // Stop streaming\n * await Opuslib.stopStreaming()\n * ```\n */\nexport { default } from './OpuslibModule'\nexport * from './Opuslib.types'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,cAAc,iBAAiB,CAAA","sourcesContent":["/**\n * Opuslib - Opus 1.6 Audio Encoding with DRED Support\n *\n * Native audio capture and Opus 1.6 encoding for React Native/Expo\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n *\n * @example\n * ```ts\n * import Opuslib from 'opuslib'\n *\n * // Start streaming with DRED enabled\n * await Opuslib.startStreaming({\n *   sampleRate: 16000,\n *   channels: 1,\n *   bitrate: 24000,\n *   frameSize: 20,\n *   framesPerCallback: 5, // batch 5 independent Opus frames per event\n *   dredDuration: 100, // 100ms DRED recovery\n * })\n *\n * // Listen for Opus packets\n * Opuslib.addListener('audioChunk', (event) => {\n *   for (const frame of event.frames) {\n *     websocket.send(frame.data)\n *   }\n * })\n *\n * // Stop streaming\n * await Opuslib.stopStreaming()\n * ```\n */\nexport { default } from './OpuslibModule'\nexport * from './Opuslib.types'\n"]}

package/ios/AudioEngineManager.swift

@@ -29,7 +29,7 @@ class AudioEngineManager {
   private var loggedFirstBuffer = false
 
   // Event callbacks
-  private var onAudioChunk: ((Data, Double, Int, Float) -> Void)?
+  private var onAudioChunk: (([EncodedFrame], Double, Int, Double, Int) -> Void)?
   private var onStarted: ((_ timestamp: Double, _ sampleRate: Int, _ channels: Int, _ bitrate: Int, _ frameSize: Double, _ preSkip: Int) -> Void)?
   private var onEnd: ((_ timestamp: Double, _ totalDuration: Double, _ totalPackets: Int) -> Void)?
   private var onAmplitude: ((Float, Float, Double) -> Void)?
@@ -59,8 +59,8 @@ class AudioEngineManager {
 
     // Create and start AudioProcessor (encoding thread)
     let proc = AudioProcessor(config: config)
-    proc.setOnAudioChunk { [weak self] data, timestamp, seq, level in
-      self?.onAudioChunk?(data, timestamp, seq, level)
+    proc.setOnAudioChunk { [weak self] frames, timestamp, seq, duration, frameCount in
+      self?.onAudioChunk?(frames, timestamp, seq, duration, frameCount)
     }
     proc.setOnStarted { [weak self] timestamp, sampleRate, channels, bitrate, frameSize, preSkip in
       self?.onStarted?(timestamp, sampleRate, channels, bitrate, frameSize, preSkip)
@@ -159,7 +159,7 @@ class AudioEngineManager {
 
   // MARK: - Event Handlers
 
-  func setOnAudioChunk(_ callback: @escaping (Data, Double, Int, Float) -> Void) {
+  func setOnAudioChunk(_ callback: @escaping ([EncodedFrame], Double, Int, Double, Int) -> Void) {
     self.onAudioChunk = callback
   }
 

package/ios/AudioProcessor.swift

@@ -11,6 +11,12 @@ import Foundation
  * - audioStarted/audioEnd events are emitted from the encoding queue,
  *   so preSkip/sequenceNumber are read without cross-thread risk
  */
+/// A single encoded Opus frame with optional per-frame audio level
+struct EncodedFrame {
+  let data: Data
+  let audioLevel: Float?  // nil when enableAudioLevel is false
+}
+
 class AudioProcessor {
   // Dedicated serial queue — equivalent to boost::asio::io_context + thread / HandlerThread
   private let queue = DispatchQueue(label: "com.opuslib.encoding", qos: .userInitiated)
@@ -19,20 +25,20 @@ class AudioProcessor {
   private var opusEncoder: OpusEncoder?
   private var pendingSamples: [Int16] = []
   private let samplesPerFrame: Int
+  private let framesPerPacket: Int  // how many frames to batch before emitting
+  private var packetFrames: [EncodedFrame] = []  // independent Opus packets with per-frame level
   private var sequenceNumber: Int = 0
   private var startTime: Double = 0
 
-  // Audio level: accumulate RMS over ~360ms window
-  private var levelSumSquares: Double = 0.0
-  private var levelSampleCount: Int = 0
-  private let levelUpdateSamples: Int
-  private var currentLevel: Float = 0.0
+  // Whether to compute per-frame audio level
+  private let enableAudioLevel: Bool
 
   // Debug file
   private var pcmFileHandle: FileHandle?
 
   // Event callbacks (all invoked on encoding queue)
-  private var onAudioChunk: ((Data, Double, Int, Float) -> Void)?
+  // onAudioChunk: (frames, timestamp, sequenceNumber, duration, frameCount)
+  private var onAudioChunk: (([EncodedFrame], Double, Int, Double, Int) -> Void)?
   private var onStarted: ((_ timestamp: Double, _ sampleRate: Int, _ channels: Int, _ bitrate: Int, _ frameSize: Double, _ preSkip: Int) -> Void)?
   private var onEnd: ((_ timestamp: Double, _ totalDuration: Double, _ totalPackets: Int) -> Void)?
 
@@ -42,8 +48,9 @@ class AudioProcessor {
   init(config: AudioConfig) {
     self.config = config
     self.samplesPerFrame = Int(Double(config.sampleRate) * config.frameSize / 1000.0)
-    let windowMs = config.audioLevelWindow ?? 360
-    self.levelUpdateSamples = config.sampleRate * config.channels * windowMs / 1000
+    let framesPerCallback = config.framesPerCallback ?? 1
+    self.framesPerPacket = max(1, framesPerCallback)
+    self.enableAudioLevel = config.enableAudioLevel ?? false
   }
 
   // MARK: - Public API
@@ -128,7 +135,7 @@ class AudioProcessor {
 
   // MARK: - Event callbacks
 
-  func setOnAudioChunk(_ callback: @escaping (Data, Double, Int, Float) -> Void) {
+  func setOnAudioChunk(_ callback: @escaping ([EncodedFrame], Double, Int, Double, Int) -> Void) {
     self.onAudioChunk = callback
   }
 
@@ -157,7 +164,7 @@ class AudioProcessor {
         }
       }
 
-      // Encode to Opus
+      // Encode single frame to Opus
       var encodedPacket: Data?
       frameData.withUnsafeBufferPointer { bufferPointer in
         guard let baseAddress = bufferPointer.baseAddress else { return }
@@ -169,37 +176,45 @@ class AudioProcessor {
         continue
       }
 
-      // Accumulate energy for RMS over ~360ms window
-      for sample in frameData {
-        let s = Double(sample) / 32768.0
-        levelSumSquares += s * s
-      }
-      levelSampleCount += frameData.count
-
-      if levelSampleCount >= levelUpdateSamples {
-        let rms = sqrt(levelSumSquares / Double(levelSampleCount))
+      // Per-frame audio level (RMS → dBFS → 0~1)
+      var frameLevel: Float? = nil
+      if enableAudioLevel {
+        var sumSquares: Double = 0.0
+        for sample in frameData {
+          let s = Double(sample) / 32768.0
+          sumSquares += s * s
+        }
+        let rms = sqrt(sumSquares / Double(frameData.count))
         let dB = 20.0 * log10(max(rms, 1e-10))
         let dbFloor = -35.0
         let dbCeiling = -6.0
-        currentLevel = Float(max(0.0, min(1.0, (dB - dbFloor) / (dbCeiling - dbFloor))))
-        levelSumSquares = 0.0
-        levelSampleCount = 0
+        frameLevel = Float(max(0.0, min(1.0, (dB - dbFloor) / (dbCeiling - dbFloor))))
       }
 
-      let timestampMs = Date().timeIntervalSince1970 * 1000
-      onAudioChunk?(opusData, timestampMs, sequenceNumber, currentLevel)
-      sequenceNumber += 1
+      // Accumulate encoded frame as independent packet (no byte concatenation)
+      packetFrames.append(EncodedFrame(data: opusData, audioLevel: frameLevel))
+
+      // Emit when we have enough frames (framesPerCallback)
+      if packetFrames.count >= framesPerPacket {
+        let timestampMs = Date().timeIntervalSince1970 * 1000
+        let frameCount = packetFrames.count
+        let duration = Double(frameCount) * config.frameSize
+        onAudioChunk?(packetFrames, timestampMs, sequenceNumber, duration, frameCount)
+        sequenceNumber += 1
+        packetFrames.removeAll()
+      }
     }
   }
 
   private func _flushRemainingFrames() {
     guard let opusEncoder = opusEncoder else { return }
-    guard !pendingSamples.isEmpty else { return }
 
-    if pendingSamples.count < samplesPerFrame {
+    // Pad remaining PCM with silence to fill the last frame
+    if !pendingSamples.isEmpty && pendingSamples.count < samplesPerFrame {
       pendingSamples.append(contentsOf: [Int16](repeating: 0, count: samplesPerFrame - pendingSamples.count))
     }
 
+    // Encode remaining frames
     while pendingSamples.count >= samplesPerFrame {
       let frameData = Array(pendingSamples.prefix(samplesPerFrame))
       pendingSamples.removeFirst(samplesPerFrame)
@@ -211,10 +226,18 @@ class AudioProcessor {
       }
 
       guard let opusData = encodedPacket, !opusData.isEmpty else { continue }
+      // Flush frames get level 0 (silence-padded)
+      packetFrames.append(EncodedFrame(data: opusData, audioLevel: enableAudioLevel ? 0.0 : nil))
+    }
 
+    // Flush any remaining frames (even if less than framesPerPacket)
+    if !packetFrames.isEmpty {
       let timestampMs = Date().timeIntervalSince1970 * 1000
-      onAudioChunk?(opusData, timestampMs, sequenceNumber, currentLevel)
+      let frameCount = packetFrames.count
+      let duration = Double(frameCount) * config.frameSize
+      onAudioChunk?(packetFrames, timestampMs, sequenceNumber, duration, frameCount)
       sequenceNumber += 1
+      packetFrames.removeAll()
     }
   }
 }

package/ios/OpuslibModule.swift

@@ -58,12 +58,21 @@ public class OpuslibModule: Module {
     print("[OpuslibModule] ✅ AudioEngineManager created")
 
     // Set up event callbacks — audioStarted/audioEnd come from encoding thread
-    manager.setOnAudioChunk { [weak self] data, timestamp, sequenceNumber, audioLevel in
+    manager.setOnAudioChunk { [weak self] frames, timestamp, sequenceNumber, duration, frameCount in
+      // Each frame is an independent Opus packet wrapped in { data, audioLevel? }
+      let frameObjects: [[String: Any]] = frames.map { frame in
+        var obj: [String: Any] = ["data": frame.data]
+        if let level = frame.audioLevel {
+          obj["audioLevel"] = level
+        }
+        return obj
+      }
       self?.sendEvent("audioChunk", [
-        "data": data,
+        "frames": frameObjects,
         "timestamp": timestamp,
         "sequenceNumber": sequenceNumber,
-        "audioLevel": audioLevel
+        "duration": duration,
+        "frameCount": frameCount
       ])
     }
 
@@ -184,11 +193,11 @@ struct AudioConfig: Record {
   @Field var channels: Int = 1
   @Field var bitrate: Int = 24000
   @Field var frameSize: Double = 20.0
-  @Field var packetDuration: Double = 20.0
+  @Field var framesPerCallback: Int? = 1
   @Field var dredDuration: Int? = 100  // NEW: DRED recovery duration in ms
   @Field var enableAmplitudeEvents: Bool? = false
   @Field var amplitudeEventInterval: Double? = 16.0
-  @Field var audioLevelWindow: Int? = 360  // RMS window duration in ms (default 360)
+  @Field var enableAudioLevel: Bool? = false  // Enable per-frame audio level calculation
   @Field var saveDebugAudio: Bool? = false
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imcooder/opuslib",
-  "version": "0.2.1",
+  "version": "2.3.1",
   "description": "Opus 1.6 audio encoding for React Native and Expo with audio level metering and lifecycle events. Forked from Scdales/opuslib.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/src/Opuslib.types.ts

@@ -10,32 +10,44 @@ export interface AudioConfig {
   bitrate: number
   /** Frame duration in milliseconds (2.5, 5, 10, 20, 40, 60) */
   frameSize: number
-  /** Packet duration in milliseconds (typically 20-100ms) */
-  packetDuration: number
+  /** Number of Opus frames per callback (default 1). Multiple frames are returned as independent packets in frames[], reducing JS bridge calls */
+  framesPerCallback?: number
   /** DRED recovery duration in milliseconds (0-100, default 100) - NEW in Opus 1.6 */
   dredDuration?: number
   /** Enable amplitude events for waveform visualization */
   enableAmplitudeEvents?: boolean
   /** Amplitude event interval in milliseconds (default 16) */
   amplitudeEventInterval?: number
-  /** Audio level RMS window duration in milliseconds (default 360) */
-  audioLevelWindow?: number
+  /** Enable per-frame audio level calculation (default false). When enabled, each OpusFrame includes audioLevel */
+  enableAudioLevel?: boolean
   /** Save debug PCM audio to file (development only) */
   saveDebugAudio?: boolean
 }
 
+/**
+ * A single Opus frame — one complete opus_encode() output with its own TOC byte
+ */
+export interface OpusFrame {
+  /** Opus-encoded packet data (independent, decodable) */
+  data: ArrayBuffer
+  /** Per-frame audio level 0.0~1.0 (only present when enableAudioLevel is true) */
+  audioLevel?: number
+}
+
 /**
  * Audio chunk event payload (Opus-encoded data)
  */
 export interface AudioChunkEvent {
-  /** Opus-encoded audio data as ArrayBuffer */
-  data: ArrayBuffer
+  /** Array of independent Opus frames. Each frame is a complete opus_encode() output, decodable on its own */
+  frames: OpusFrame[]
   /** Timestamp in milliseconds */
   timestamp: number
-  /** Sequence number (increments with each packet) */
+  /** Sequence number (increments with each callback) */
   sequenceNumber: number
-  /** Audio level normalized to 0.0~1.0 (mapped from dBFS, 0 = silence, 1 = loud) */
-  audioLevel: number
+  /** Duration of all frames in milliseconds (frameSize * frameCount) */
+  duration: number
+  /** Number of Opus frames in this callback (= frames.length) */
+  frameCount: number
 }
 
 /**

package/src/OpuslibModule.ts

@@ -53,7 +53,7 @@ export default {
    *   channels: 1,
    *   bitrate: 24000,
    *   frameSize: 20,
-   *   packetDuration: 20,
+   *   framesPerCallback: 5, // batch 5 independent Opus packets per event
    *   dredDuration: 100, // Enable 100ms DRED recovery
    * })
    * ```
@@ -85,8 +85,10 @@ export default {
    * ```ts
    * // Listen for audio chunks
    * const subscription = Opuslib.addListener('audioChunk', (event) => {
-   *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')
-   *   websocket.send(event.data)
+   *   for (const frame of event.frames) {
+   *     console.log('Opus packet:', frame.data.byteLength, 'bytes')
+   *     websocket.send(frame.data)
+   *   }
    * })
    *
    * // Listen for errors

package/src/index.ts

@@ -14,14 +14,15 @@
  *   channels: 1,
  *   bitrate: 24000,
  *   frameSize: 20,
- *   packetDuration: 20,
+ *   framesPerCallback: 5, // batch 5 independent Opus frames per event
  *   dredDuration: 100, // 100ms DRED recovery
  * })
  *
  * // Listen for Opus packets
  * Opuslib.addListener('audioChunk', (event) => {
- *   // Send to backend
- *   websocket.send(event.data)
+ *   for (const frame of event.frames) {
+ *     websocket.send(frame.data)
+ *   }
  * })
  *
  * // Stop streaming