@edkimmel/expo-audio-stream 0.3.1 → 0.3.2-0

package/android/src/main/java/expo/modules/audiostream/AudioEffectsManager.kt

@@ -7,12 +7,27 @@ import android.media.audiofx.NoiseSuppressor
 import android.util.Log
 
 /**
- * Manages audio effects for voice recording, including:
- * - Acoustic Echo Cancellation (AEC)
- * - Noise Suppression (NS)
- * - Automatic Gain Control (AGC)
+ * Manages hardware audio effects for voice recording.
+ *
+ * We use VOICE_RECOGNITION as our audio source. The Android CDD (Section 5.4)
+ * mandates that this source delivers unprocessed audio:
+ *   [C-1-2] MUST disable noise reduction by default
+ *   [C-1-3] MUST disable automatic gain control by default
+ *
+ * NS and AGC are therefore off by default to honor the spec. Enabling them
+ * re-introduces the processing the CDD explicitly prohibits for this source
+ * and can cause low-volume capture on many OEMs.
+ *
+ * AEC is the one effect the CDD permits for VOICE_RECOGNITION ("expects a
+ * stream that has an echo cancellation effect if available"), so it is
+ * enabled by default.
  */
-class AudioEffectsManager {
+class AudioEffectsManager(
+    /** Enable hardware noise suppressor. Default false — CDD 5.4 [C-1-2] prohibits it for VOICE_RECOGNITION. */
+    private val enableNS: Boolean = false,
+    /** Enable hardware AGC. Default false — CDD 5.4 [C-1-3] prohibits it for VOICE_RECOGNITION. */
+    private val enableAGC: Boolean = false
+) {
     // Audio effects
     private var acousticEchoCanceler: AcousticEchoCanceler? = null
     private var noiseSuppressor: NoiseSuppressor? = null
@@ -41,11 +56,21 @@ class AudioEffectsManager {
                 Log.d(Constants.TAG, "Acoustic Echo Canceler enabled: ${acousticEchoCanceler?.enabled}")
             }
             
-            // Apply noise suppression
-            enableNoiseSuppression(audioSessionId)
-            
-            // Apply automatic gain control
-            enableAutomaticGainControl(audioSessionId)
+            // NS off by default — CDD 5.4 [C-1-2] prohibits it for VOICE_RECOGNITION.
+            // Enabling it can aggressively attenuate speech on many OEMs.
+            if (enableNS) {
+                enableNoiseSuppression(audioSessionId)
+            } else {
+                Log.d(Constants.TAG, "Noise Suppressor skipped (CDD 5.4 [C-1-2])")
+            }
+
+            // AGC off by default — CDD 5.4 [C-1-3] prohibits it for VOICE_RECOGNITION.
+            // Hardware AGC is also unreliable across devices.
+            if (enableAGC) {
+                enableAutomaticGainControl(audioSessionId)
+            } else {
+                Log.d(Constants.TAG, "Hardware AGC skipped (CDD 5.4 [C-1-3])")
+            }
             
         } catch (e: Exception) {
             Log.e(Constants.TAG, "Error setting up audio effects", e)

package/android/src/main/java/expo/modules/audiostream/AudioRecorderManager.kt

@@ -330,6 +330,7 @@ class AudioRecorderManager(
 
                 if (bytesRead > 0) {
                     consecutiveErrors = 0
+                    gainNormalizer.apply(audioData, bytesRead)
                     totalDataSize += bytesRead
                     // Emit immediately — each read is one interval of audio
                     emitAudioData(audioData, bytesRead)

package/android/src/main/java/expo/modules/audiostream/GainNormalizer.kt

@@ -0,0 +1,83 @@
+package expo.modules.audiostream
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Adaptive gain normalizer for PCM-16 audio.
+ *
+ * Measures per-chunk RMS and adjusts a smoothed gain multiplier to push
+ * speech toward [targetLevelDbfs].  Attack is fast (captures the start of
+ * an utterance quickly), release is slow (holds gain through pauses and
+ * plosives so it doesn't clip the next syllable).
+ *
+ * Yes, this is effectively AGC — the CDD says VOICE_RECOGNITION shouldn't
+ * have it, but the raw levels on many devices are too low for third-party
+ * server-side VAD that we don't control.  Pragmatism wins.
+ */
+class GainNormalizer(
+    /** Target RMS level in dBFS.  -16 is loud enough for most VAD services. */
+    private val targetLevelDbfs: Float = -16f,
+
+    /** RMS below this is silence — don't adapt gain during silence. */
+    private val silenceThresholdDbfs: Float = -50f,
+
+    /** Attack coefficient (0–1).  Lower = faster.  0.2 ≈ ramps up in 2–3 chunks. */
+    private val attackCoeff: Float = 0.2f,
+
+    /** Release coefficient (0–1).  Higher = slower.  0.95 ≈ holds through ~500ms pause at 100ms chunks. */
+    private val releaseCoeff: Float = 0.95f,
+
+    /** Hard ceiling on gain to prevent blowing up near-silence into noise. */
+    private val maxGain: Float = 10.0f,
+
+    /** Minimum gain — never attenuate below unity. */
+    private val minGain: Float = 1.0f
+) {
+    private var currentGain: Float = 1.0f
+
+    /**
+     * Process a PCM-16 LE chunk in place.
+     *
+     * @param data   PCM-16 little-endian byte array
+     * @param length valid bytes (must be even)
+     */
+    fun apply(data: ByteArray, length: Int): ByteArray {
+        val buf = ByteBuffer.wrap(data, 0, length).order(ByteOrder.LITTLE_ENDIAN)
+        val sampleCount = length / 2
+
+        // --- measure RMS ---
+        var sumSquares = 0.0
+        for (i in 0 until sampleCount) {
+            val s = buf.getShort(i * 2).toInt()
+            sumSquares += s.toDouble() * s.toDouble()
+        }
+        val rms = Math.sqrt(sumSquares / sampleCount).toFloat()
+        val rmsDbfs = if (rms > 0f) 20f * Math.log10(rms.toDouble() / Short.MAX_VALUE).toFloat() else -100f
+
+        // --- adapt gain (only during speech, not silence) ---
+        if (rmsDbfs > silenceThresholdDbfs) {
+            val desiredGain = Math.pow(10.0, (targetLevelDbfs - rmsDbfs).toDouble() / 20.0)
+                .toFloat()
+                .coerceIn(minGain, maxGain)
+
+            // Fast attack, slow release
+            val coeff = if (desiredGain < currentGain) attackCoeff else releaseCoeff
+            currentGain = coeff * currentGain + (1f - coeff) * desiredGain
+        }
+        // During silence: hold currentGain — don't adapt, don't reset.
+
+        if (currentGain < 1.01f) return data  // unity, skip work
+
+        // --- apply gain ---
+        for (i in 0 until sampleCount) {
+            val offset = i * 2
+            val sample = buf.getShort(offset).toInt()
+            val amplified = (sample * currentGain).toInt()
+                .coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt())
+            buf.putShort(offset, amplified.toShort())
+        }
+
+        return data
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edkimmel/expo-audio-stream",
-  "version": "0.3.1",
+  "version": "0.3.2-0",
   "description": "Expo Play Audio Stream module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -45,5 +45,6 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
-  }
+  },
+  "stableVersion": "0.3.1"
 }