@gmessier/nitro-speech 0.3.3 → 0.4.1

package/android/src/main/java/com/margelo/nitro/nitrospeech/recognizer/AutoStopper.kt

@@ -2,38 +2,102 @@ package com.margelo.nitro.nitrospeech.recognizer
 
 import android.os.Handler
 import android.os.Looper
-import android.util.Log
+import kotlin.math.max
 
-class AutoStopper (
-    private var silenceThreshold: Long,
-    val forceStopRecording: () -> Unit,
+class AutoStopper(
+    silenceThresholdMs: Double?,
+    progressIntervalMs: Double?,
+    private val onProgress: (Double) -> Unit,
+    val onTimeout: () -> Unit,
 ) {
     companion object {
-        private const val TAG = "HybridRecognizer"
+        private const val DEFAULT_SILENCE_THRESHOLD_MS = 8000.0
+        private const val DEFAULT_PROGRESS_INTERVAL_MS = 1000.0
+        private const val MIN_PROGRESS_INTERVAL_MS = 50.0
     }
 
+    private val logger = Logger(disable = false)
+
+    private var silenceThresholdMs: Double = clampMs(silenceThresholdMs ?: DEFAULT_SILENCE_THRESHOLD_MS)
+    private var progressIntervalMs: Double = clampMs(progressIntervalMs ?: DEFAULT_PROGRESS_INTERVAL_MS)
+
+    private var timeLeftMs: Double = this.silenceThresholdMs
     private var isStopped = false
+    private var didTimeout = false
+    private var isTimerScheduled = false
+
     private val handler = Handler(Looper.getMainLooper())
 
-    private val autoStopRecording = Runnable {
-        if (isStopped) return@Runnable
-        Log.d(TAG, "forceStopRecording, ms: ${System.currentTimeMillis()}")
-        forceStopRecording()
-    }
+    private val tickRunnable = Runnable { tick() }
 
-    fun indicateRecordingActivity() {
-        Log.d(TAG, "indicateRecordingActivity | isStopped: $isStopped | ms: ${System.currentTimeMillis()}")
-        handler.removeCallbacks(autoStopRecording)
+    fun resetTimer() {
+        logger.log("resetTimer | isStopped: $isStopped | ms: ${System.currentTimeMillis()}")
+        handler.removeCallbacks(tickRunnable)
+        isTimerScheduled = false
         if (isStopped) return
-        handler.postDelayed(autoStopRecording, silenceThreshold)
+        didTimeout = false
+        timeLeftMs = silenceThresholdMs
+        if (timeLeftMs > 0) {
+            onProgress(timeLeftMs)
+        }
+        scheduleNextTickLocked()
     }
 
     fun stop() {
         isStopped = true
-        handler.removeCallbacks(autoStopRecording)
+        handler.removeCallbacks(tickRunnable)
+        isTimerScheduled = false
+    }
+
+    fun updateSilenceThreshold(newThresholdMs: Double) {
+        silenceThresholdMs = clampMs(newThresholdMs)
+    }
+
+    fun addMsOnce(extraMs: Double) {
+        if (isStopped || !extraMs.isFinite()) return
+        logger.log("addMsOnce | extraMs: $extraMs")
+        timeLeftMs += extraMs
+        didTimeout = false
+        if (timeLeftMs > 0 && isTimerScheduled) {
+            onProgress(timeLeftMs)
+        }
+    }
+
+    fun updateProgressInterval(newIntervalMs: Double) {
+        if (isStopped) return
+        logger.log("updateProgressInterval | newIntervalMs: $newIntervalMs")
+        progressIntervalMs = clampMs(newIntervalMs)
+        if (isTimerScheduled) {
+            scheduleNextTickLocked()
+        }
+    }
+
+    private fun scheduleNextTickLocked() {
+        handler.removeCallbacks(tickRunnable)
+        val delayMs = progressIntervalMs.toLong().coerceAtLeast(MIN_PROGRESS_INTERVAL_MS.toLong())
+        handler.postDelayed(tickRunnable, delayMs)
+        isTimerScheduled = true
+    }
+
+    private fun tick() {
+        if (isStopped || didTimeout) return
+        timeLeftMs -= progressIntervalMs
+        if (timeLeftMs > 0) {
+            logger.log("onProgress | timeLeftMs: $timeLeftMs")
+            onProgress(timeLeftMs)
+            scheduleNextTickLocked()
+            return
+        }
+        timeLeftMs = 0.0
+        didTimeout = true
+        handler.removeCallbacks(tickRunnable)
+        isTimerScheduled = false
+        logger.log("onTimeout | ms: ${System.currentTimeMillis()}")
+        onTimeout()
     }
 
-    fun updateSilenceThreshold(newThreshold: Long) {
-        silenceThreshold = newThreshold
+    private fun clampMs(value: Double): Double {
+        if (!value.isFinite()) return MIN_PROGRESS_INTERVAL_MS
+        return max(MIN_PROGRESS_INTERVAL_MS, value)
     }
-}
+}

package/android/src/main/java/com/margelo/nitro/nitrospeech/recognizer/HybridRecognizer.kt

@@ -7,21 +7,27 @@ import android.os.Handler
 import android.os.Looper
 import android.speech.RecognizerIntent
 import android.speech.SpeechRecognizer
-import android.util.Log
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nitrospeech.MutableSpeechRecognitionConfig
 import com.margelo.nitro.nitrospeech.HybridRecognizerSpec
-import com.margelo.nitro.nitrospeech.SpeechToTextParams
+import com.margelo.nitro.nitrospeech.SpeechRecognitionConfig
+import com.margelo.nitro.nitrospeech.VolumeChangeEvent
 
+@DoNotStrip
+@Keep
 class HybridRecognizer: HybridRecognizerSpec() {
   companion object {
-    private const val TAG = "HybridRecognizer"
     private const val POST_RECOGNITION_DELAY = 250L
   }
 
+  private val logger = Logger(disable = false)
+
   private var isActive: Boolean = false
-  private var config: SpeechToTextParams? = null
+  private var config: SpeechRecognitionConfig? = null
+  private var volumeChangeEvent: VolumeChangeEvent = VolumeChangeEvent(0.0,0.0,null)
   private var autoStopper: AutoStopper? = null
   private var speechRecognizer: SpeechRecognizer? = null
   private val mainHandler = Handler(Looper.getMainLooper())
@@ -33,16 +39,20 @@ class HybridRecognizer: HybridRecognizerSpec() {
   override var onAutoFinishProgress: ((timeLeftMs: Double) -> Unit)? = null
   override var onError: ((error: String) -> Unit)? = null
   override var onPermissionDenied: (() -> Unit)? = null
-  override var onVolumeChange: ((normVolume: Double) -> Unit)? = null
+  override var onVolumeChange: ((event: VolumeChangeEvent) -> Unit)? = null
 
-  override fun getIsActive(): Boolean {
-    return isActive
+  @DoNotStrip
+  @Keep
+  override fun prewarm(defaultParams: SpeechRecognitionConfig?): Promise<Unit> {
+    // no-op
+    // nothing to prewarm
+    return Promise()
   }
 
   @DoNotStrip
   @Keep
-  override fun startListening(params: SpeechToTextParams) {
-    Log.d(TAG, "startListening: $params")
+  override fun startListening(params: SpeechRecognitionConfig?) {
+    logger.log("startListening: $params")
     if (isActive) {
       onFinishRecognition(
         null,
@@ -85,7 +95,7 @@ class HybridRecognizer: HybridRecognizerSpec() {
   @DoNotStrip
   @Keep
   override fun stopListening() {
-    Log.d(TAG, "stopListening called")
+    logger.log("stopListening called")
     if (!isActive) return
     onFinishRecognition(null, null, true)
     mainHandler.postDelayed({
@@ -98,25 +108,90 @@ class HybridRecognizer: HybridRecognizerSpec() {
     }, POST_RECOGNITION_DELAY)
   }
 
+  @DoNotStrip
+  @Keep
+  override fun resetAutoFinishTime() {
+    if (!isActive) return
+    autoStopper?.resetTimer()
+  }
+
   @DoNotStrip
   @Keep
   override fun addAutoFinishTime(additionalTimeMs: Double?) {
-    Log.d(TAG, "stopListening called")
+    logger.log("addAutoFinishTime")
     if (!isActive) return
-    autoStopper?.indicateRecordingActivity()
+
+    if (additionalTimeMs != null) {
+      autoStopper?.addMsOnce(additionalTimeMs)
+    } else {
+      // Reset timer to original baseline.
+      autoStopper?.resetTimer()
+    }
   }
 
   @DoNotStrip
   @Keep
-  override fun updateAutoFinishTime(newTimeMs: Double, withRefresh: Boolean?) {
-    Log.d(TAG, "updateAutoFinishTime: $newTimeMs")
+  override fun updateConfig(
+    newConfig: MutableSpeechRecognitionConfig?,
+    resetAutoFinishTime: Boolean?
+  ) {
+    logger.log("updateConfig $newConfig",)
     if (!isActive) return
-    autoStopper?.updateSilenceThreshold(newTimeMs.toLong())
-    if (withRefresh == true) {
-      autoStopper?.indicateRecordingActivity()
+
+    val newTimeMs = if (newConfig?.autoFinishRecognitionMs != null) newConfig.autoFinishRecognitionMs else config?.autoFinishRecognitionMs
+    if (newTimeMs != null && newTimeMs != config?.autoFinishRecognitionMs) {
+      autoStopper?.updateSilenceThreshold(newTimeMs)
+    }
+    val newInterval = if (newConfig?.autoFinishProgressIntervalMs != null) newConfig.autoFinishProgressIntervalMs else config?.autoFinishProgressIntervalMs
+    if (newInterval != null && newInterval != config?.autoFinishProgressIntervalMs) {
+      autoStopper?.updateProgressInterval(newInterval)
+    }
+
+    if (resetAutoFinishTime == true) {
+      autoStopper?.resetTimer()
     }
+
+    if (newConfig != null) {
+      config = SpeechRecognitionConfig(
+        locale = config?.locale,
+        contextualStrings = config?.contextualStrings,
+        maskOffensiveWords = config?.maskOffensiveWords,
+        autoFinishRecognitionMs = newConfig.autoFinishRecognitionMs ?: config?.autoFinishRecognitionMs,
+        autoFinishProgressIntervalMs = newConfig.autoFinishProgressIntervalMs ?: config?.autoFinishProgressIntervalMs,
+        resetAutoFinishVoiceSensitivity = newConfig.resetAutoFinishVoiceSensitivity ?: config?.resetAutoFinishVoiceSensitivity,
+        disableRepeatingFilter = newConfig.disableRepeatingFilter ?: config?.disableRepeatingFilter,
+        startHapticFeedbackStyle = newConfig.startHapticFeedbackStyle ?: config?.startHapticFeedbackStyle,
+        stopHapticFeedbackStyle = newConfig.stopHapticFeedbackStyle ?: config?.stopHapticFeedbackStyle,
+        androidFormattingPreferQuality = config?.androidFormattingPreferQuality,
+        androidUseWebSearchModel = config?.androidUseWebSearchModel,
+        androidDisableBatchHandling = config?.androidDisableBatchHandling,
+        iosAddPunctuation = config?.iosAddPunctuation,
+        iosPreset = config?.iosPreset,
+        iosAtypicalSpeech = config?.iosAtypicalSpeech
+      )
+    }
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun getIsActive(): Boolean {
+    return isActive
   }
 
+  @DoNotStrip
+  @Keep
+  override fun getVoiceInputVolume(): VolumeChangeEvent {
+    return volumeChangeEvent
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun getSupportedLocalesIOS(): Array<String> {
+    return emptyArray()
+  }
+
+  @DoNotStrip
+  @Keep
   override fun dispose() {
     stopListening()
   }
@@ -125,19 +200,25 @@ class HybridRecognizer: HybridRecognizerSpec() {
     mainHandler.post {
       try {
         speechRecognizer = SpeechRecognizer.createSpeechRecognizer(context)
-        val silenceThreshold = config?.autoFinishRecognitionMs?.toLong() ?: 8000
         autoStopper = AutoStopper(
-            silenceThreshold,
-        ) {
-            stopListening()
-        }
+            silenceThresholdMs = config?.autoFinishRecognitionMs,
+            progressIntervalMs = config?.autoFinishProgressIntervalMs,
+            onProgress = { timeLeftMs ->
+              onAutoFinishProgress?.invoke(timeLeftMs)
+            },
+            onTimeout = {
+              stopListening()
+            }
+        )
         val recognitionListenerSession = RecognitionListenerSession(
-          autoStopper,
-          config,
-          onVolumeChange
-        ) { result: ArrayList<String>?, errorMessage: String?, recordingStopped: Boolean ->
-          onFinishRecognition(result, errorMessage, recordingStopped)
-        }
+            autoStopper,
+            config,
+            fireVolumeChangeEvent = { event -> fireVolumeChangeEvent(event) },
+            onFinishRecognition = { result, errorMessage, recordingStopped ->
+              onFinishRecognition(result, errorMessage, recordingStopped)
+            }
+        )
+
         speechRecognizer?.setRecognitionListener(recognitionListenerSession.createRecognitionListener())
 
         val languageModel = if (config?.androidUseWebSearchModel == true) RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH else RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
@@ -175,6 +256,7 @@ class HybridRecognizer: HybridRecognizerSpec() {
           if (isActive) {
             onReadyForSpeech?.invoke()
             onFinishRecognition(arrayListOf(), null, false)
+            autoStopper?.resetTimer()
           }
         }, 500)
       } catch (e: Exception) {
@@ -189,7 +271,7 @@ class HybridRecognizer: HybridRecognizerSpec() {
 
   private fun cleanup() {
     try {
-      Log.d(TAG, "stopListening called")
+      logger.log("cleanup called")
       autoStopper?.stop()
       autoStopper = null
       speechRecognizer?.stopListening()
@@ -197,7 +279,7 @@ class HybridRecognizer: HybridRecognizerSpec() {
       speechRecognizer = null
       isActive = false
       // Reset voice meter in JS consumers after stop/error cleanup.
-      onVolumeChange?.invoke(0.0)
+      fireVolumeChangeEvent(VolumeChangeEvent(0.0,0.0,null))
     } catch (e: Exception) {
       onFinishRecognition(
         null,
@@ -218,4 +300,10 @@ class HybridRecognizer: HybridRecognizerSpec() {
       onResult?.invoke(result.toTypedArray())
     }
   }
+
+  private fun fireVolumeChangeEvent(event: VolumeChangeEvent) {
+    logger.log("fireVolumeChangeEvent ${event}")
+    volumeChangeEvent = event
+    onVolumeChange?.invoke(event)
+  }
 }

package/android/src/main/java/com/margelo/nitro/nitrospeech/recognizer/Logger.kt

@@ -0,0 +1,16 @@
+package com.margelo.nitro.nitrospeech.recognizer
+
+import android.util.Log
+
+class Logger (
+  private val disable: Boolean
+) {
+  private val isLogging = false
+  companion object {
+    private const val TAG = "HybridRecognizer"
+  }
+  fun log(message: String) {
+    if (disable || !isLogging) return
+    Log.d(TAG, message)
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrospeech/recognizer/RecognitionListenerSession.kt

@@ -3,20 +3,20 @@ package com.margelo.nitro.nitrospeech.recognizer
 import android.os.Bundle
 import android.speech.RecognitionListener
 import android.speech.SpeechRecognizer
-import android.util.Log
-import com.margelo.nitro.nitrospeech.SpeechToTextParams
+import com.margelo.nitro.nitrospeech.SpeechRecognitionConfig
+import com.margelo.nitro.nitrospeech.VolumeChangeEvent
 import kotlin.math.max
 import kotlin.math.roundToInt
 
 class RecognitionListenerSession (
     private val autoStopper: AutoStopper?,
-    private val config: SpeechToTextParams?,
-    private val onVolumeChange: ((normVolume: Double) -> Unit)?,
+    private val config: SpeechRecognitionConfig?,
+    private val fireVolumeChangeEvent: (event: VolumeChangeEvent) -> Unit,
     private val onFinishRecognition: (result: ArrayList<String>?, errorMessage: String?, recordingStopped: Boolean) -> Unit,
 ) {
+    private val logger = Logger(disable = false)
     companion object {
-        private const val TAG = "HybridRecognizer"
-        private const val SPEECH_LEVEL_THRESHOLD = 0.08f
+        private const val SPEECH_LEVEL_THRESHOLD = 0.35
         private const val FLOOR_RISE_ALPHA = 0.01f
         private const val FLOOR_FALL_ALPHA = 0.20f
         private const val PEAK_ATTACK_ALPHA = 0.25f
@@ -38,10 +38,14 @@ class RecognitionListenerSession (
             override fun onReadyForSpeech(params: Bundle?) {}
             override fun onBeginningOfSpeech() {}
             override fun onRmsChanged(rmsdB: Float) {
-                val normLevel = normalizeRmsDb(rmsdB)
-                onVolumeChange?.invoke(normLevel.toDouble())
-                if (normLevel > SPEECH_LEVEL_THRESHOLD) {
-                    autoStopper?.indicateRecordingActivity()
+                val volumeEvent = getVolume(rmsdB)
+                fireVolumeChangeEvent(volumeEvent)
+                val threshold =
+                    config?.resetAutoFinishVoiceSensitivity?.coerceIn(0.0, 1.0)
+                        ?: SPEECH_LEVEL_THRESHOLD.toDouble()
+                // logger.log("onRmsChanged: ${volumeEvent}")
+                if (volumeEvent.rawVolume > threshold) {
+                    autoStopper?.resetTimer()
                 }
             }
             override fun onBufferReceived(buffer: ByteArray?) {}
@@ -66,40 +70,40 @@ class RecognitionListenerSession (
                     true
                 )
                 autoStopper?.stop()
-                autoStopper?.forceStopRecording()
+                autoStopper?.onTimeout()
             }
 
             override fun onResults(results: Bundle?) {
-                Log.d(TAG, "onResults: $resultBatches")
+                logger.log("onResults: $resultBatches")
                 onFinishRecognition(resultBatches, null, true)
                 autoStopper?.stop()
-                autoStopper?.forceStopRecording()
+                autoStopper?.onTimeout()
             }
 
             override fun onPartialResults(partialResults: Bundle?) {
-                autoStopper?.indicateRecordingActivity()
                 val matches = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
 
                 if (matches.isNullOrEmpty() || matches[0] == "") {
-                    Log.d(TAG, "onPartialResults[0], skip, NO RECOGNIZE")
+                    logger.log("onPartialResults[0], skip, NO RECOGNIZE")
                     return
                 }
 
-                Log.d(TAG, "onPartialResults[0], add ${matches[0]}")
+                autoStopper?.resetTimer()
+                logger.log("onPartialResults[0], add ${matches[0]}")
                 var currentBatches = resultBatches
                 if (currentBatches.isNullOrEmpty()) {
-                    Log.d(TAG, "onPartialResults[1], NO BATCHES YET | add first")
+                    logger.log("onPartialResults[1], NO BATCHES YET | add first")
                     currentBatches = arrayListOf(matches[0])
                 } else {
-                    Log.d(TAG, "onPartialResults[1], current batches $currentBatches")
+                    logger.log("onPartialResults[1], current batches $currentBatches")
                     val prevBatchLength = currentBatches[currentBatches.lastIndex].length
                     val match = if (config?.disableRepeatingFilter == true) matches[0] else repeatingFilter(matches[0])
                     val matchLength = match.length
                     if (config?.androidDisableBatchHandling == true || matchLength + 3 < prevBatchLength) {
-                        Log.d(TAG, "onPartialResults[2], append new batch")
+                        logger.log("onPartialResults[2], append new batch")
                         currentBatches.add(match)
                     } else {
-                        Log.d(TAG, "onPartialResults[2], update batch, replace #${currentBatches.lastIndex}")
+                        logger.log("onPartialResults[2], update batch, replace #${currentBatches.lastIndex}")
                         currentBatches[currentBatches.lastIndex] = match
                     }
                 }
@@ -144,9 +148,9 @@ class RecognitionListenerSession (
         return joiner.toString()
     }
 
-    private fun normalizeRmsDb(rmsdB: Float): Double {
+    private fun getVolume(rmsdB: Float): VolumeChangeEvent {
         if (!rmsdB.isFinite()) {
-            return 0.0
+            return VolumeChangeEvent(0.0,0.0,null)
         }
 
         if (noiseFloorDb.isNaN()) {
@@ -166,7 +170,14 @@ class RecognitionListenerSession (
         val raw = ((rmsdB - noiseFloorDb) / span).coerceIn(0f, 1f)
         val smoothingCoeff = if (raw > levelSmoothed) METER_ATTACK else METER_RELEASE
         levelSmoothed += smoothingCoeff * (raw - levelSmoothed)
-
-        return ((levelSmoothed * PRECISION_SCALE).roundToInt() / PRECISION_SCALE).toDouble()
+        val roundedSmoothed = ((levelSmoothed * PRECISION_SCALE).roundToInt() / PRECISION_SCALE).toDouble()
+        val roundedRaw = ((raw * PRECISION_SCALE).roundToInt() / PRECISION_SCALE).toDouble()
+        val db = (rmsdB * 1000).roundToInt() / 1000.0
+
+        return VolumeChangeEvent(
+            smoothedVolume = roundedSmoothed,
+            rawVolume = roundedRaw,
+            db = db
+        )
     }
   }

package/ios/{BufferUtil.swift → Audio/AudioBufferConverter.swift}

@@ -1,6 +1,5 @@
 import Foundation
 import AVFoundation
-import Accelerate
 
 private final class SendablePCMBufferBox: @unchecked Sendable {
     let buffer: AVAudioPCMBuffer
@@ -10,42 +9,12 @@ private final class SendablePCMBufferBox: @unchecked Sendable {
     }
 }
 
-class BufferUtil {
-    private static let meterMinDb: Float = -70   // silence floor
-    private static let meterMaxDb: Float = -10   // loud speech ceiling
-    private static let meterAttack: Float = 0.35 // rise speed
-    private static let meterRelease: Float = 0.08 // fall speed
-    
-    func calcRmsVolume(
-        levelSmoothed: Float,
-        buffer: AVAudioPCMBuffer
-    ) -> (Float, Float)? {
-        guard let samples = buffer.floatChannelData?[0] else { return nil }
-        
-        let frameL = Int(buffer.frameLength)
-        var rms: Float = 0
-        
-        vDSP_rmsqv(samples, 1, &rms, vDSP_Length(frameL))
-        
-        // 2) RMS -> dBFS
-        let db = 20 * log10(rms + 0.00001)
-
-        // 3) Normalize dB to 0...1
-        let raw = (db - Self.meterMinDb) / (Self.meterMaxDb - Self.meterMinDb)
-        let normalized = max(0, min(1, raw))
-
-        // 4) Smooth (fast attack, slow release)
-        let coeff = normalized > levelSmoothed ? Self.meterAttack : Self.meterRelease
-        let nextLevelSmoothed = levelSmoothed + coeff * (normalized - levelSmoothed)
-        
-        return (rms, nextLevelSmoothed)
-    }
-
-    func convertBuffer(
+enum AudioBufferConverter {
+    static func convertBuffer(
         converter: AVAudioConverter,
         audioFormat: AVAudioFormat,
         pcmBuffer: AVAudioPCMBuffer
-    ) throws -> AVAudioPCMBuffer?  {
+    ) throws -> AVAudioPCMBuffer? {
         let resampledCapacity = AVAudioFrameCount(
             (Double(pcmBuffer.frameLength) * (audioFormat.sampleRate / pcmBuffer.format.sampleRate)).rounded(.up)
         )

package/ios/Audio/AudioLevelTracker.swift

@@ -0,0 +1,60 @@
+import Foundation
+import AVFoundation
+import Accelerate
+
+struct AudioLevelSample {
+    let smoothed: Double
+    let raw: Double
+    let db: Double
+    let resetTimer: Bool
+}
+
+final class AudioLevelTracker {
+    private static let meterMinDb: Float = -70
+    private static let meterMaxDb: Float = -10
+    private static let meterAttack: Float = 0.35
+    private static let meterRelease: Float = 0.08
+    private static let defaultAutoStopResetThreshold: Double = 0.4
+
+    private var smoothedLevel: Float = 0
+
+    var currentSample: AudioLevelSample?
+    
+    private let lg = Lg(prefix: "RecognizerEngine")
+
+    func reset() {
+        smoothedLevel = 0
+        currentSample = nil
+    }
+
+    func process(_ buffer: AVAudioPCMBuffer,_ autoStopResetThreshold: Double? = nil) -> AudioLevelSample? {
+        guard let samples = buffer.floatChannelData?[0] else { return nil }
+
+        let frameCount = Int(buffer.frameLength)
+        var rms: Float = 0
+        vDSP_rmsqv(samples, 1, &rms, vDSP_Length(frameCount))
+
+        let db = 20 * log10(rms + 0.00001)
+        let raw = (db - Self.meterMinDb) / (Self.meterMaxDb - Self.meterMinDb)
+        let normalized = max(0, min(1, raw))
+
+        let coeff = normalized > smoothedLevel ? Self.meterAttack : Self.meterRelease
+        smoothedLevel += coeff * (normalized - smoothedLevel)
+        
+        var threshold = Self.defaultAutoStopResetThreshold
+        if let autoStopResetThreshold {
+            threshold = max(0, min(1, autoStopResetThreshold))
+        }
+
+        currentSample = AudioLevelSample(
+            smoothed: Double(smoothedLevel * 1_000_000).rounded() / 1_000_000,
+            raw: Double(normalized * 1_000_000).rounded() / 1_000_000,
+            db: Double(db * 1_000).rounded() / 1_000,
+            resetTimer: Double(normalized) >= threshold
+        )
+        
+        lg.log("[AudioLevelTracker.process] autoStopResetThreshold: \(threshold)")
+        
+        return currentSample
+    }
+}