react-native-sherpa-onnx 0.3.2 → 0.3.3

package/android/src/main/java/com/sherpaonnx/SherpaOnnxPcmCapture.kt

@@ -0,0 +1,150 @@
+package com.sherpaonnx
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import android.util.Base64
+import android.util.Log
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.concurrent.thread
+import kotlin.math.round
+
+/**
+ * Native PCM capture from the microphone with optional resampling to a target sample rate.
+ * Captures at a supported hardware rate (e.g. 44100 or 48000 Hz), then resamples to the
+ * requested rate so the app always receives PCM at the same sample rate (e.g. 16000 for STT).
+ */
+class SherpaOnnxPcmCapture(
+  private val targetSampleRate: Int,
+  private val channelCount: Int,
+  private val bufferSizeFrames: Int,
+  private val onChunk: (base64Pcm: String, sampleRate: Int) -> Unit,
+  private val onError: (message: String) -> Unit,
+  private val logTag: String = "SherpaOnnxPcmCapture"
+) {
+  private var audioRecord: AudioRecord? = null
+  @Volatile
+  private var running = false
+  private var captureThread: Thread? = null
+
+  companion object {
+    /** Supported capture sample rates to try in order (device-dependent). */
+    private val CAPTURE_RATES = intArrayOf(16000, 44100, 48000)
+
+    /**
+     * Resample Int16 PCM from capture rate to target rate using linear interpolation.
+     * Returns a new ByteArray of Int16 samples at target rate.
+     */
+    private fun resampleInt16(
+      input: ShortArray,
+      fromRate: Int,
+      toRate: Int
+    ): ShortArray {
+      if (fromRate == toRate) return input
+      val ratio = fromRate.toDouble() / toRate
+      val outLength = round(input.size / ratio).toInt().coerceAtLeast(0)
+      val result = ShortArray(outLength)
+      for (i in 0 until outLength) {
+        val srcIdx = i * ratio
+        val idx0 = srcIdx.toInt().coerceIn(0, input.size - 1)
+        val idx1 = (idx0 + 1).coerceAtMost(input.size - 1)
+        val frac = (srcIdx - idx0).toFloat()
+        val v0 = input[idx0].toInt()
+        val v1 = input[idx1].toInt()
+        result[i] = (v0 + (v1 - v0) * frac).toInt().toShort()
+      }
+      return result
+    }
+  }
+
+  /**
+   * Start capture. Uses a supported hardware rate and resamples to [targetSampleRate] before emitting.
+   */
+  fun start() {
+    if (running) {
+      Log.w(logTag, "start: already running")
+      return
+    }
+    val bufferSizeBytes = if (bufferSizeFrames > 0) {
+      bufferSizeFrames * 2 // 2 bytes per sample (16-bit mono)
+    } else {
+      (0.1 * targetSampleRate).toInt() * 2 // 0.1 s default (16-bit mono)
+    }
+    val captureRate = CAPTURE_RATES.firstOrNull { rate ->
+      val size = AudioRecord.getMinBufferSize(rate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT)
+      size != AudioRecord.ERROR && size != AudioRecord.ERROR_BAD_VALUE
+    } ?: 44100
+    val minBuf = AudioRecord.getMinBufferSize(captureRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT)
+    val bufSize = minBuf.coerceAtLeast(bufferSizeBytes)
+    val record = try {
+      AudioRecord(
+        MediaRecorder.AudioSource.VOICE_RECOGNITION,
+        captureRate,
+        AudioFormat.CHANNEL_IN_MONO,
+        AudioFormat.ENCODING_PCM_16BIT,
+        bufSize
+      )
+    } catch (e: SecurityException) {
+      Log.e(logTag, "start: RECORD_AUDIO permission not granted", e)
+      onError("RECORD_AUDIO permission not granted")
+      return
+    }
+    if (record.state != AudioRecord.STATE_INITIALIZED) {
+      Log.e(logTag, "start: AudioRecord not initialized")
+      onError("AudioRecord failed to initialize")
+      record.release()
+      return
+    }
+    audioRecord = record
+    running = true
+    captureThread = thread(name = "SherpaOnnxPcmCapture") {
+      val shortBuf = ShortArray(bufSize / 2)
+      try {
+        record.startRecording()
+        while (running && record.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
+          val read = record.read(shortBuf, 0, shortBuf.size)
+          if (read <= 0) continue
+          val chunk = shortBuf.copyOf(read)
+          val toEmit = if (captureRate != targetSampleRate) {
+            resampleInt16(chunk, captureRate, targetSampleRate)
+          } else {
+            chunk
+          }
+          val byteBuf = ByteBuffer.allocate(toEmit.size * 2).order(ByteOrder.LITTLE_ENDIAN)
+          for (s in toEmit) byteBuf.putShort(s)
+          val base64 = Base64.encodeToString(byteBuf.array(), Base64.NO_WRAP)
+          onChunk(base64, targetSampleRate)
+        }
+      } catch (e: Exception) {
+        if (running) {
+          Log.e(logTag, "Capture thread error", e)
+          onError(e.message ?: "Capture error")
+        }
+      } finally {
+        try {
+          record.stop()
+        } catch (_: Exception) { }
+        record.release()
+        audioRecord = null
+      }
+    }
+  }
+
+  /** Stop capture and release resources. */
+  fun stop() {
+    running = false
+    // Actively stop AudioRecord to unblock any pending read()
+    val record = audioRecord
+    if (record != null) {
+      try {
+        record.stop()
+      } catch (_: Exception) {
+        // Ignore; the capture thread's finally block also handles stop/release safely
+      }
+    }
+    captureThread?.join(2000)
+    captureThread = null
+    audioRecord = null
+  }
+}

package/android/src/main/java/com/sherpaonnx/SherpaOnnxSttHelper.kt

@@ -2,6 +2,7 @@ package com.sherpaonnx
 
 import android.content.Context
 import android.net.Uri
+import android.os.HandlerThread
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
@@ -51,6 +52,9 @@ internal class SherpaOnnxSttHelper(
 
   private val instances = ConcurrentHashMap<String, SttEngineInstance>()
 
+  private val initThread = HandlerThread("stt-init").also { it.start() }
+  private val initHandler = android.os.Handler(initThread.looper)
+
   private fun getInstance(instanceId: String): SttEngineInstance? = instances[instanceId]
 
   /** Hotwords are supported for transducer and NeMo transducer models (sherpa-onnx; NeMo: https://github.com/k2-fsa/sherpa-onnx/pull/3077). */
@@ -277,26 +281,33 @@ internal class SherpaOnnxSttHelper(
       )
       inst.lastRecognizerConfig = config
       inst.currentSttModelType = modelTypeStr
-      inst.recognizer = OfflineRecognizer(config = config)
-
-      
-
-      val resultMap = Arguments.createMap()
-      resultMap.putBoolean("success", true)
-      resultMap.putString("modelType", modelTypeStr)
-      resultMap.putString("decodingMethod", config.decodingMethod)
-      val detectedModelsArray = Arguments.createArray()
-      for (model in detectedModels) {
-        val modelMap = model as? HashMap<*, *>
-        if (modelMap != null) {
-          val modelResultMap = Arguments.createMap()
-          modelResultMap.putString("type", modelMap["type"] as? String ?: "")
-          modelResultMap.putString("modelDir", modelMap["modelDir"] as? String ?: "")
-          detectedModelsArray.pushMap(modelResultMap)
+      // Defer recognizer creation to the dedicated background thread so release() of the previous
+      // recognizer can complete off the UI thread (avoids "destroyed mutex" / SIGSEGV when switching models).
+      initHandler.post {
+        try {
+          inst.recognizer = OfflineRecognizer(config = config)
+          val resultMap = Arguments.createMap()
+          resultMap.putBoolean("success", true)
+          resultMap.putString("modelType", modelTypeStr)
+          resultMap.putString("decodingMethod", config.decodingMethod)
+          val detectedModelsArray = Arguments.createArray()
+          for (model in detectedModels) {
+            val modelMap = model as? HashMap<*, *>
+            if (modelMap != null) {
+              val modelResultMap = Arguments.createMap()
+              modelResultMap.putString("type", modelMap["type"] as? String ?: "")
+              modelResultMap.putString("modelDir", modelMap["modelDir"] as? String ?: "")
+              detectedModelsArray.pushMap(modelResultMap)
+            }
+          }
+          resultMap.putArray("detectedModels", detectedModelsArray)
+          promise.resolve(resultMap)
+        } catch (e: Exception) {
+          val errorMsg = "Exception creating recognizer: ${e.message ?: e.javaClass.simpleName}"
+          Log.e(logTag, errorMsg, e)
+          promise.reject("INIT_ERROR", errorMsg, e)
         }
       }
-      resultMap.putArray("detectedModels", detectedModelsArray)
-      promise.resolve(resultMap)
     } catch (e: Exception) {
       val errorMsg = "Exception during initialization: ${e.message ?: e.javaClass.simpleName}"
       Log.e(logTag, errorMsg, e)
@@ -588,7 +599,16 @@ internal class SherpaOnnxSttHelper(
           preprocessor = path(paths, "moonshinePreprocessor"),
           encoder = path(paths, "moonshineEncoder"),
           uncachedDecoder = path(paths, "moonshineUncachedDecoder"),
-          cachedDecoder = path(paths, "moonshineCachedDecoder")
+          cachedDecoder = path(paths, "moonshineCachedDecoder"),
+          mergedDecoder = ""
+        ),
+        tokens = path(paths, "tokens"),
+        modelType = "moonshine"
+      )
+      "moonshine_v2" -> OfflineModelConfig(
+        moonshine = OfflineMoonshineModelConfig(
+          encoder = path(paths, "moonshineEncoder"),
+          mergedDecoder = path(paths, "moonshineMergedDecoder")
         ),
         tokens = path(paths, "tokens"),
         modelType = "moonshine"

package/ios/SherpaOnnx+PcmLiveStream.mm

@@ -0,0 +1,288 @@
+/**
+ * SherpaOnnx+PcmLiveStream.mm
+ *
+ * Native PCM live capture from the microphone via Audio Queue API (AudioQueueNewInput).
+ * Captures at a supported hardware rate (16000, 44100, 48000), resamples to the requested
+ * target rate, and emits pcmLiveStreamData at target rate (same behavior as Android).
+ */
+
+#import "SherpaOnnx.h"
+#import <AVFoundation/AVFoundation.h>
+#import <AudioToolbox/AudioToolbox.h>
+#import <React/RCTLog.h>
+#import <stdlib.h>
+
+static const UInt32 kPcmLiveAQNumberBuffers = 3;
+/** Capture sample rates to try in order (match Android CAPTURE_RATES). */
+static const int kPcmLiveCaptureRates[] = { 16000, 44100, 48000 };
+static const size_t kPcmLiveCaptureRatesCount = sizeof(kPcmLiveCaptureRates) / sizeof(kPcmLiveCaptureRates[0]);
+
+static NSInteger _pcmLiveTargetSampleRate = 16000;
+static NSInteger _pcmLiveCaptureRate = 16000;
+static __weak SherpaOnnx *_pcmLiveModule = nil;
+static AudioQueueRef _pcmLiveAudioQueue = NULL;
+static AudioQueueBufferRef _pcmLiveAQBuffers[kPcmLiveAQNumberBuffers];
+static volatile BOOL _pcmLiveAQRunning = NO;
+
+static void emitPcmChunk(SherpaOnnx *module, const int16_t *samples, NSUInteger count, NSInteger sampleRate) {
+  if (!module || count == 0) return;
+  // Copy samples into NSData on the AudioQueue callback thread so the data
+  // remains valid after the audio buffer is reused.
+  NSData *data = [NSData dataWithBytes:samples length:count * sizeof(int16_t)];
+  // Dispatch the React Native event emission to the main queue to avoid
+  // bridge thread-safety issues.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSString *base64 = [data base64EncodedStringWithOptions:0];
+    [module sendEventWithName:@"pcmLiveStreamData"
+                        body:@{ @"base64Pcm": base64, @"sampleRate": @(sampleRate) }];
+  });
+}
+
+static void emitPcmError(SherpaOnnx *module, NSString *message) {
+  if (!module) return;
+  // Dispatch error events to the main queue to match other RN event patterns
+  // and avoid bridge thread-safety issues.
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [module sendEventWithName:@"pcmLiveStreamError" body:@{ @"message": message ?: @"" }];
+  });
+}
+
+/** Resample Int16 PCM from fromRate to toRate using linear interpolation (match Android resampleInt16). */
+static NSUInteger pcmLiveResampleInt16(const int16_t *input, NSUInteger inputFrames,
+                                      int fromRate, int toRate,
+                                      int16_t *output, size_t outputCapacity) {
+  if (fromRate == toRate) {
+    size_t copy = (inputFrames < outputCapacity) ? inputFrames : outputCapacity;
+    memcpy(output, input, copy * sizeof(int16_t));
+    return copy;
+  }
+  double ratio = (double)fromRate / (double)toRate;
+  NSUInteger outLength = (NSUInteger)((double)inputFrames / ratio);
+  if (outLength > outputCapacity) outLength = outputCapacity;
+  if (outLength == 0) return 0;
+  for (NSUInteger i = 0; i < outLength; i++) {
+    double srcIdx = (double)i * ratio;
+    NSUInteger idx0 = (NSUInteger)srcIdx;
+    if (idx0 >= inputFrames) idx0 = inputFrames - 1;
+    NSUInteger idx1 = idx0 + 1;
+    if (idx1 >= inputFrames) idx1 = inputFrames - 1;
+    float frac = (float)(srcIdx - (double)idx0);
+    int v0 = (int)input[idx0];
+    int v1 = (int)input[idx1];
+    int v = (int)(v0 + (v1 - v0) * frac);
+    if (v < -32768) v = -32768;
+    if (v > 32767) v = 32767;
+    output[i] = (int16_t)v;
+  }
+  return outLength;
+}
+
+static void pcmLiveAQInputCallback(void *inUserData,
+                                   AudioQueueRef inAQ,
+                                   AudioQueueBufferRef inBuffer,
+                                   const AudioTimeStamp *inStartTime,
+                                   UInt32 inNumPackets,
+                                   const AudioStreamPacketDescription *inPacketDesc) {
+  (void)inUserData;
+  (void)inStartTime;
+  (void)inNumPackets;
+  (void)inPacketDesc;
+  if (!_pcmLiveAQRunning) return;
+  SherpaOnnx *module = _pcmLiveModule;
+  if (!module) return;
+  UInt32 byteSize = inBuffer->mAudioDataByteSize;
+  if (byteSize == 0) {
+    AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
+    return;
+  }
+  const int16_t *samples = (const int16_t *)inBuffer->mAudioData;
+  NSUInteger count = byteSize / sizeof(int16_t);
+  NSInteger targetRate = _pcmLiveTargetSampleRate;
+  NSInteger captureRate = _pcmLiveCaptureRate;
+
+  if (captureRate == targetRate) {
+    emitPcmChunk(module, samples, count, targetRate);
+  } else {
+    // Compute an upper bound on the number of output frames for resampling.
+    NSUInteger maxOutFrames =
+        (count * (NSUInteger)targetRate + (NSUInteger)captureRate - 1) /
+        (NSUInteger)captureRate;
+    if (maxOutFrames == 0) {
+      AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
+      return;
+    }
+    int16_t *resampleBuf = (int16_t *)malloc(maxOutFrames * sizeof(int16_t));
+    if (resampleBuf == NULL) {
+      emitPcmError(module, @"Failed to allocate resample buffer");
+      AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
+      return;
+    }
+    NSUInteger outFrames = pcmLiveResampleInt16(samples, count,
+                                               (int)captureRate, (int)targetRate,
+                                               resampleBuf, maxOutFrames);
+    if (outFrames > 0)
+      emitPcmChunk(module, resampleBuf, outFrames, targetRate);
+    free(resampleBuf);
+  }
+  AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
+}
+
+static void pcmLiveStopQueue(void) {
+  if (_pcmLiveAudioQueue == NULL) return;
+  _pcmLiveAQRunning = NO;
+  AudioQueueStop(_pcmLiveAudioQueue, true);
+  for (UInt32 i = 0; i < kPcmLiveAQNumberBuffers; i++) {
+    if (_pcmLiveAQBuffers[i] != NULL) {
+      AudioQueueFreeBuffer(_pcmLiveAudioQueue, _pcmLiveAQBuffers[i]);
+      _pcmLiveAQBuffers[i] = NULL;
+    }
+  }
+  AudioQueueDispose(_pcmLiveAudioQueue, true);
+  _pcmLiveAudioQueue = NULL;
+}
+
+@implementation SherpaOnnx (PcmLiveStream)
+
+- (void)startPcmLiveStream:(id __unsafe_unretained)optionsArg
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject
+{
+  int targetRate = 16000;
+  UInt32 bufferSizeFrames = 0;
+
+  // Parse optionsArg coming from JS (fallback / non-codegen path).
+  if ([optionsArg isKindOfClass:[NSDictionary class]]) {
+    NSDictionary *dict = (NSDictionary *)optionsArg;
+
+    id sampleRateValue = dict[@"sampleRate"];
+    if ([sampleRateValue respondsToSelector:@selector(intValue)]) {
+      int v = (int)[sampleRateValue intValue];
+      if (v > 0) targetRate = v;
+    }
+
+    id bufferSizeValue = dict[@"bufferSizeFrames"];
+    if ([bufferSizeValue respondsToSelector:@selector(doubleValue)]) {
+      double v = [bufferSizeValue doubleValue];
+      if (v > 0) bufferSizeFrames = (UInt32)v;
+    }
+  }
+
+  [self _startPcmLiveStreamWithTargetRate:targetRate bufferSizeFrames:bufferSizeFrames resolve:resolve reject:reject];
+}
+
+#if __has_include(<SherpaOnnxSpec/SherpaOnnxSpec.h>)
+- (void)startPcmLiveStreamWithOptions:(JS::NativeSherpaOnnx::SpecStartPcmLiveStreamOptions &)options
+                             resolve:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject
+{
+  int targetRate = 16000;
+  if (options.sampleRate()) {
+    targetRate = (int)options.sampleRate();
+    if (targetRate <= 0) targetRate = 16000;
+  }
+  UInt32 bufferSizeFrames = 0;
+  if (options.bufferSizeFrames().has_value()) {
+    double v = options.bufferSizeFrames().value();
+    if (v > 0) bufferSizeFrames = (UInt32)v;
+  }
+  [self _startPcmLiveStreamWithTargetRate:targetRate bufferSizeFrames:bufferSizeFrames resolve:resolve reject:reject];
+}
+#endif
+
+- (void)_startPcmLiveStreamWithTargetRate:(int)targetRate
+                       bufferSizeFrames:(UInt32)bufferSizeFrames
+                                 resolve:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject
+{
+  pcmLiveStopQueue();
+
+  _pcmLiveTargetSampleRate = targetRate;
+  _pcmLiveModule = self;
+
+  NSError *error = nil;
+  AVAudioSession *session = [AVAudioSession sharedInstance];
+  if (![session setCategory:AVAudioSessionCategoryPlayAndRecord
+                       mode:AVAudioSessionModeDefault
+                    options:AVAudioSessionCategoryOptionDefaultToSpeaker | AVAudioSessionCategoryOptionAllowBluetooth
+                      error:&error]) {
+    RCTLog(@"%@", [NSString stringWithFormat:@"[SherpaOnnx PcmLive] setCategory error: %@", error]);
+    reject(@"PCM_LIVE_STREAM_ERROR", error.localizedDescription ?: @"Failed to set audio session", error);
+    return;
+  }
+  if (![session setActive:YES withOptions:0 error:&error]) {
+    RCTLog(@"%@", [NSString stringWithFormat:@"[SherpaOnnx PcmLive] setActive error: %@", error]);
+    reject(@"PCM_LIVE_STREAM_ERROR", error.localizedDescription ?: @"Failed to activate audio session", error);
+    return;
+  }
+
+  AudioStreamBasicDescription fmt;
+  memset(&fmt, 0, sizeof(fmt));
+  fmt.mFormatID = kAudioFormatLinearPCM;
+  fmt.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
+  fmt.mChannelsPerFrame = 1;
+  fmt.mBitsPerChannel = 16;
+  fmt.mBytesPerPacket = 2;
+  fmt.mBytesPerFrame = 2;
+  fmt.mFramesPerPacket = 1;
+
+  OSStatus status = noErr;
+  int chosenCaptureRate = 16000;
+  for (size_t r = 0; r < kPcmLiveCaptureRatesCount; r++) {
+    chosenCaptureRate = kPcmLiveCaptureRates[r];
+    fmt.mSampleRate = (Float64)chosenCaptureRate;
+    status = AudioQueueNewInput(&fmt, pcmLiveAQInputCallback, NULL, NULL, NULL, 0, &_pcmLiveAudioQueue);
+    if (status == noErr) break;
+    _pcmLiveAudioQueue = NULL;
+  }
+  if (status != noErr || _pcmLiveAudioQueue == NULL) {
+    [session setActive:NO withOptions:0 error:nil];
+    reject(@"PCM_LIVE_STREAM_ERROR", [NSString stringWithFormat:@"AudioQueueNewInput failed for all rates (last: %d)", (int)status], nil);
+    return;
+  }
+  _pcmLiveCaptureRate = chosenCaptureRate;
+
+  UInt32 bufferByteSize = 2048;
+  if (bufferSizeFrames > 0) {
+    bufferByteSize = bufferSizeFrames * 2;  /* 16-bit mono */
+    if (bufferByteSize < 1024) bufferByteSize = 1024;
+    if (bufferByteSize > 32768) bufferByteSize = 32768;
+  }
+
+  for (UInt32 i = 0; i < kPcmLiveAQNumberBuffers; i++) {
+    status = AudioQueueAllocateBuffer(_pcmLiveAudioQueue, bufferByteSize, &_pcmLiveAQBuffers[i]);
+    if (status != noErr) {
+      pcmLiveStopQueue();
+      [session setActive:NO withOptions:0 error:nil];
+      reject(@"PCM_LIVE_STREAM_ERROR", [NSString stringWithFormat:@"AudioQueueAllocateBuffer failed: %d", (int)status], nil);
+      return;
+    }
+    AudioQueueEnqueueBuffer(_pcmLiveAudioQueue, _pcmLiveAQBuffers[i], 0, NULL);
+  }
+
+  _pcmLiveAQRunning = YES;
+  status = AudioQueueStart(_pcmLiveAudioQueue, NULL);
+  if (status != noErr) {
+    pcmLiveStopQueue();
+    [session setActive:NO withOptions:0 error:nil];
+    reject(@"PCM_LIVE_STREAM_ERROR", [NSString stringWithFormat:@"AudioQueueStart failed: %d", (int)status], nil);
+    return;
+  }
+
+  resolve(nil);
+}
+
+- (void)stopPcmLiveStream:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+  [self stopPcmLiveStreamWithResolve:resolve reject:reject];
+}
+
+- (void)stopPcmLiveStreamWithResolve:(RCTPromiseResolveBlock)resolve
+                             reject:(RCTPromiseRejectBlock)reject
+{
+  pcmLiveStopQueue();
+  [[AVAudioSession sharedInstance] setActive:NO withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation error:nil];
+  resolve(nil);
+}
+
+@end

package/ios/SherpaOnnx+STT.mm

@@ -38,6 +38,7 @@ static NSString *sttModelKindToNSString(sherpaonnx::SttModelKind kind) {
         case K::kFunAsrNano: return @"funasr_nano";
         case K::kFireRedAsr: return @"fire_red_asr";
         case K::kMoonshine: return @"moonshine";
+        case K::kMoonshineV2: return @"moonshine_v2";
         case K::kDolphin: return @"dolphin";
         case K::kCanary: return @"canary";
         case K::kOmnilingual: return @"omnilingual";
@@ -268,6 +269,7 @@ static NSDictionary *sttResultToDict(const sherpaonnx::SttRecognitionResult& r)
 
         NSMutableDictionary *resultDict = [NSMutableDictionary dictionary];
         resultDict[@"success"] = @(result.ok);
+        resultDict[@"isHardwareSpecificUnsupported"] = @(result.isHardwareSpecificUnsupported);
         if (!result.error.empty()) {
             resultDict[@"error"] = [NSString stringWithUTF8String:result.error.c_str()];
         }

package/ios/SherpaOnnx.mm

@@ -36,7 +36,7 @@
 
 - (NSArray<NSString *> *)supportedEvents
 {
-    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError", @"extractTarBz2Progress" ];
+    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError", @"extractTarBz2Progress", @"pcmLiveStreamData", @"pcmLiveStreamError" ];
 }
 
 - (void)resolveModelPath:(JS::NativeSherpaOnnx::SpecResolveModelPathConfig &)config

package/ios/model_detect/sherpa-onnx-model-detect-helper.h

@@ -21,12 +21,11 @@ std::vector<std::string> ListDirectories(const std::string& path);
 std::vector<FileEntry> ListFiles(const std::string& path);
 std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth);
 std::string ToLower(std::string value);
-std::string ResolveTokenizerDir(const std::string& modelDir);
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth);
+/** Find file in \p files whose name equals \p fileName (case-insensitive). Uses file tree only, no filesystem. */
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName);
 /** Find file whose name equals or ends with suffix (e.g. tokens.txt, tiny-tokens.txt) in a pre-built file list. */
 std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix);
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth);
 
 std::string FindOnnxByToken(
     const std::vector<FileEntry>& files,
@@ -38,6 +37,13 @@ std::string FindOnnxByAnyToken(
     const std::vector<std::string>& tokens,
     const std::optional<bool>& preferInt8
 );
+/** Like FindOnnxByAnyToken but skips any file whose nameLower contains any of \p excludeInName. */
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+);
 std::string FindLargestOnnxExcludingTokens(
     const std::vector<FileEntry>& files,
     const std::vector<std::string>& excludeTokens