react-native-nitro-onnx 0.1.0 → 0.1.1

package/NitroOnnxSpeech.podspec

@@ -41,9 +41,11 @@ Pod::Spec.new do |s|
   # to match the inner framework name (SherpaOnnxC.framework), which CocoaPods
   # requires for correct linker flag generation.
   s.vendored_frameworks = "cpp/sherpa-onnx-prebuilt/ios/SherpaOnnxC.xcframework"
+  puts "[NitroOnnxSpeech] 🔧 CoreML execution provider enabled for iOS"
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => '"$(PODS_TARGET_SRCROOT)/cpp/sherpa-onnx-prebuilt/include" "$(PODS_TARGET_SRCROOT)/cpp" "$(PODS_TARGET_SRCROOT)/nitrogen/generated/ios"',
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) SHERPA_ONNX_ENABLE_COREML=1"
   }
 
   load 'nitrogen/generated/ios/NitroOnnxSpeech+autolinking.rb'

package/README.md

@@ -22,7 +22,7 @@ All audio I/O uses zero-copy `ArrayBuffer` with **16 kHz mono f32 PCM**.
 - [Model File Requirements](#model-file-requirements)
 - [Installation](#installation)
 - [Usage](#usage)
-- [Qualcomm CPU Detection](#qualcomm-cpu-detection)
+- [Execution Providers](#execution-providers)
 - [VAD Pre-buffer](#vad-pre-buffer)
 - [Voice Cloning](#voice-cloning)
 - [Threading](#threading)
@@ -304,32 +304,67 @@ await tts.saveWav(audio, "/path/to/output.wav");
 > source.start();
 > ```
 
-## Qualcomm CPU Detection
+## Execution Providers
 
-Use `isQualcommCpu()` to detect Qualcomm chipsets and select optimized QNN execution providers:
+By default, the module automatically selects the best execution provider for your platform:
+
+- **Android:** `qnn` — uses Qualcomm NPU via QNN; unsupported operators fall back to NNAPI/CPU.
+- **iOS:** `coreml` — uses Apple Neural Engine via CoreML; unsupported operators fall back to CPU.
+
+To disable NPU acceleration and force CPU-only inference, pass `provider: "cpu"` explicitly:
+
+```typescript
+await asr.load({
+  type: "whisper",
+  // ... other config
+  provider: "cpu",
+});
+```
+
+### Qualcomm SoC Detection
+
+Use `getQualcommSoc()` to detect Qualcomm chipsets. Returns the SoC model string (e.g. `"SM8550"`, `"SM8650"`) on Qualcomm Android devices, or an empty string on iOS and non-Qualcomm chips.
+
+On Android, it first reads the `ro.soc.model` system property, then falls back to parsing `/proc/cpuinfo`.
 
 ```typescript
 const speech = getOnnxSpeech();
-const isQualcomm = speech.isQualcommCpu();
-
-if (isQualcomm) {
-  // Use QNN execution provider for better performance on Qualcomm chips
-  await asr.load({
-    type: "whisper",
-    // ... other config
-    provider: "qnn",
-  });
+const soc = speech.getQualcommSoc();
+
+if (soc) {
+  console.log(`Qualcomm SoC: ${soc}`);
+  // QNN is the default provider on Android — no need to specify it
+  await asr.load({ type: "whisper", /* ... */ });
 } else {
-  // Use CPU or other execution provider
-  await asr.load({
-    type: "whisper",
-    // ... other config
-    provider: "cpu",
-  });
+  await asr.load({ type: "whisper", /* ... */ provider: "cpu" });
 }
 ```
 
-> **Note:** `isQualcommCpu()` returns `false` on iOS. It checks `/proc/cpuinfo` on Android to detect Qualcomm processors.
+> **Note:** `getQualcommSoc()` returns `""` on iOS.
+
+### Building with QNN Support
+
+QNN is enabled by default on Android (the prebuilt sherpa-onnx libraries include QNN support). You do **not** need `QNN_ROOT` for normal usage.
+
+`QNN_ROOT` is **only** required when you need to bundle additional QNN Binary backend libraries from the Qualcomm AI Runtime (QAIRT) SDK. If you don't need the binary backend, simply omit `QNN_ROOT` — the default QNN execution provider works out of the box.
+
+**Download QAIRT SDK (only if you need QNN Binary):**
+
+Visit [Qualcomm Software Center](https://softwarecenter.qualcomm.com/api/download/software/sdks/Qualcomm_AI_Runtime_Community/All/2.40.0.251030/v2.40.0.251030.zip) to download the SDK (v2.40.0).
+
+**Specify QNN_ROOT (optional):**
+
+```bash
+# Via environment variable
+QNN_ROOT=/path/to/qnn/sdk ./gradlew assembleRelease
+
+# Or in android/gradle.properties
+QNN_ROOT=/path/to/qnn/sdk
+```
+
+When `QNN_ROOT` is set, the build system will link the QNN core library (`QnnHtp`) and all available HTP version libraries (`QnnHtpV73Stub`/`HtpV73`, `QnnHtpV75Stub`/`HtpV75`, etc.) from the SDK.
+
+> **Note:** QNN support is Android-only. On iOS, CoreML is used by default.
 
 ## VAD Pre-buffer
 

package/android/CMakeLists.txt

@@ -115,3 +115,54 @@ if(ANDROID)
 endif()
 find_package(Threads REQUIRED)
 target_link_libraries(${PROJECT_NAME} Threads::Threads)
+
+# QNN SDK support: pass -DQNN_ROOT=/path/to/qnn/sdk to enable QNN execution provider
+set(QNN_ROOT "" CACHE PATH "Path to Qualcomm QNN SDK root directory")
+if(QNN_ROOT)
+  message(NOTICE "🔧 QNN execution provider enabled")
+  message(NOTICE "📁 QNN SDK path: ${QNN_ROOT}")
+  target_include_directories(${PROJECT_NAME} PRIVATE "${QNN_ROOT}/include")
+  target_compile_definitions(${PROJECT_NAME} PRIVATE SHERPA_ONNX_ENABLE_QNN)
+
+  # QNN libraries are in lib/<arch>/ e.g. lib/aarch64-android/
+  set(_QNN_LIB_DIR "${QNN_ROOT}/lib/aarch64-android")
+  if(NOT EXISTS "${_QNN_LIB_DIR}")
+    # Fallback for older SDK layouts
+    set(_QNN_LIB_DIR "${QNN_ROOT}/lib/hexagon-v73")
+  endif()
+
+  # Link QNN core library
+  if(EXISTS "${_QNN_LIB_DIR}/libQnnHtp.so")
+    add_library(QnnHtp SHARED IMPORTED)
+    set_target_properties(QnnHtp PROPERTIES
+      IMPORTED_LOCATION "${_QNN_LIB_DIR}/libQnnHtp.so"
+    )
+    target_link_libraries(${PROJECT_NAME} QnnHtp)
+  endif()
+
+  # Link all available HTP version stubs and runtimes (v73, v75, v79, v81, etc.)
+  file(GLOB _QNN_HEXAGON_DIRS "${QNN_ROOT}/lib/hexagon-v*")
+  foreach(_HEXAGON_DIR ${_QNN_HEXAGON_DIRS})
+    get_filename_component(_HEXAGON_NAME "${_HEXAGON_DIR}" NAME)
+    # Extract version number from "hexagon-v73" -> "73"
+    string(REGEX REPLACE ".*hexagon-v([0-9]+).*" "\\1" _HTP_VER "${_HEXAGON_NAME}")
+    if(_HTP_VER)
+      set(_STUB_LIB "QnnHtpV${_HTP_VER}Stub")
+      set(_RUNTIME_LIB "HtpV${_HTP_VER}")
+
+      foreach(_QNN_LIB ${_STUB_LIB} ${_RUNTIME_LIB})
+        set(_LIB_PATH "${_HEXAGON_DIR}/lib${_QNN_LIB}.so")
+        if(EXISTS "${_LIB_PATH}")
+          add_library(${_QNN_LIB} SHARED IMPORTED)
+          set_target_properties(${_QNN_LIB} PROPERTIES
+            IMPORTED_LOCATION "${_LIB_PATH}"
+          )
+          target_link_libraries(${PROJECT_NAME} ${_QNN_LIB})
+        endif()
+      endforeach()
+    endif()
+  endforeach()
+else()
+  message(NOTICE "🔧 QNN execution provider enabled (without external SDK)")
+  target_compile_definitions(${PROJECT_NAME} PRIVATE SHERPA_ONNX_ENABLE_QNN)
+endif()

package/android/build.gradle

@@ -24,6 +24,12 @@ android {
         arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
 
+        // Pass QNN_ROOT to CMake if provided via gradle.properties or env var
+        def qnnRoot = findProperty("QNN_ROOT") ?: System.getenv("QNN_ROOT")
+        if (qnnRoot) {
+          arguments "-DQNN_ROOT=${qnnRoot}"
+        }
+
         buildTypes {
           debug {
             cppFlags "-O1 -g"

package/android/src/main/java/com/margelo/nitro/onnx/speech/OnnxSpeechPackage.kt

@@ -57,9 +57,9 @@ class OnnxSpeechPackage : ReactPackage {
     }
   }
 
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
     ensureResources(reactContext)
-    return emptyList()
+    return super.getModule(name, reactContext)
   }
 
   @Suppress("OVERRIDE_DEPRECATION")

package/cpp/AsrEngine.cpp

@@ -96,7 +96,8 @@ void OfflineAsrEngine::load(const AsrEngineConfig& config) {
 
     c.model_config.tokens = tokens.c_str();
     c.model_config.num_threads = config_.numThreads;
-    c.model_config.debug = 0;
+    c.model_config.debug = config_.debug ? 1 : 0;
+    c.model_config.provider = config_.provider.c_str();
     c.decoding_method = config_.decodingMethod.c_str();
     c.max_active_paths = config_.maxActivePaths;
 
@@ -201,6 +202,8 @@ void StreamingAsrEngine::load(
 
     c.model_config.tokens = tokens.c_str();
     c.model_config.num_threads = config_.numThreads;
+    c.model_config.debug = config_.debug ? 1 : 0;
+    c.model_config.provider = config_.provider.c_str();
     c.decoding_method = config_.decodingMethod.c_str();
     c.max_active_paths = config_.maxActivePaths;
     c.enable_endpoint = 1;

package/cpp/AsrEngine.hpp

@@ -41,6 +41,14 @@ struct AsrEngineConfig {
   int32_t maxActivePaths = 4;
   std::string language = "en";
   bool useItn = true;
+  bool debug = false;
+#ifdef __ANDROID__
+  std::string provider = "qnn";
+#elif defined(__APPLE__)
+  std::string provider = "coreml";
+#else
+  std::string provider = "cpu";
+#endif
 };
 
 /** Native recognition result before conversion to the generated AsrResult. */

package/cpp/NitroOnnxSpeech.cpp

@@ -13,6 +13,10 @@
 #include <cstdio>
 #include <cstring>
 
+#ifdef __ANDROID__
+#include <sys/system_properties.h>
+#endif
+
 namespace margelo::nitro::onnx::speech {
 
 NitroOnnxSpeech::NitroOnnxSpeech()
@@ -46,23 +50,39 @@ std::string NitroOnnxSpeech::getVersion() {
   return "0.1.0";
 }
 
-bool NitroOnnxSpeech::isQualcommCpu() {
+std::string NitroOnnxSpeech::getQualcommSoc() {
 #ifdef __ANDROID__
+  // 1) Try ro.soc.model first (available on most modern Android devices).
+  char prop[PROP_VALUE_MAX] = {0};
+  if (__system_property_get("ro.soc.model", prop) > 0 && prop[0] != '\0') {
+    return std::string(prop);
+  }
+
+  // 2) Fall back to parsing /proc/cpuinfo Hardware line.
   FILE* f = fopen("/proc/cpuinfo", "r");
-  if (!f) return false;
+  if (!f) return "";
   char line[256];
-  bool found = false;
   while (fgets(line, sizeof(line), f)) {
-    if (strstr(line, "Qualcomm") != nullptr) {
-      found = true;
-      break;
+    if (strncmp(line, "Hardware", 8) == 0) {
+      char* colon = strchr(line, ':');
+      if (!colon) break;
+      char* val = colon + 1;
+      while (*val == ' ' || *val == '\t') ++val;
+      char* nl = strchr(val, '\n');
+      if (nl) *nl = '\0';
+      if (strstr(val, "Qualcomm") == nullptr) break;
+      const char* last = strrchr(val, ' ');
+      if (last && *(last + 1) != '\0') {
+        fclose(f);
+        return std::string(last + 1);
+      }
+      fclose(f);
+      return std::string(val);
     }
   }
   fclose(f);
-  return found;
-#else
-  return false;
 #endif
+  return "";
 }
 
 }  // namespace margelo::nitro::onnx::speech

package/cpp/NitroOnnxSpeech.hpp

@@ -32,7 +32,7 @@ class NitroOnnxSpeech : public HybridOnnxSpeechSpec {
   std::shared_ptr<HybridTtsSpec> createTts() override;
   std::shared_ptr<HybridSpeakerManagerSpec> createSpeakerManager() override;
   std::string getVersion() override;
-  bool isQualcommCpu() override;
+  std::string getQualcommSoc() override;
 
  private:
   std::shared_ptr<ThreadPool> threadPool_;

package/cpp/OfflineAsr.cpp

@@ -53,6 +53,18 @@ std::shared_ptr<Promise<void>> OfflineAsr::load(const AsrModelConfig& config) {
     native.maxActivePaths = static_cast<int32_t>(config.maxActivePaths.value_or(4));
     native.language = config.language.value_or("en");
     native.useItn = config.useItn.value_or(true);
+    native.debug = config.debug.value_or(false);
+#ifdef __ANDROID__
+  #if defined(SHERPA_ONNX_ENABLE_QNN)
+    native.provider = config.provider.value_or("qnn");
+  #else
+    native.provider = config.provider.value_or("nnapi");
+  #endif
+#elif defined(__APPLE__)
+    native.provider = config.provider.value_or("coreml");
+#else
+    native.provider = config.provider.value_or("cpu");
+#endif
     engine_.load(native);
   });
 }

package/cpp/StreamingAsr.cpp

@@ -47,6 +47,14 @@ std::shared_ptr<Promise<void>> StreamingAsr::load(const AsrModelConfig& config)
     native.numThreads = static_cast<int32_t>(config.numThreads.value_or(2));
     native.decodingMethod = config.decodingMethod.value_or("greedy_search");
     native.maxActivePaths = static_cast<int32_t>(config.maxActivePaths.value_or(4));
+    native.debug = config.debug.value_or(false);
+#ifdef __ANDROID__
+    native.provider = config.provider.value_or("qnn");
+#elif defined(__APPLE__)
+    native.provider = config.provider.value_or("coreml");
+#else
+    native.provider = config.provider.value_or("cpu");
+#endif
     engine_.load(native, shared_cast<StreamingAsr>());
   });
 }

package/cpp/Tts.cpp

@@ -57,6 +57,12 @@ std::shared_ptr<Promise<void>> Tts::load(const TtsModelConfig& config) {
     native.outputSampleRate = static_cast<int32_t>(config.outputSampleRate.value_or(16000.0));
     native.speakerId = static_cast<int32_t>(config.speakerId.value_or(0.0));
     native.speed = static_cast<float>(config.speed.value_or(1.0));
+    native.debug = config.debug.value_or(false);
+#ifdef __APPLE__
+    native.provider = config.provider.value_or("coreml");
+#else
+    native.provider = config.provider.value_or("cpu");
+#endif
     engine_.load(native);
   });
 }

package/cpp/TtsEngine.cpp

@@ -146,8 +146,8 @@ void TtsEngine::load(const TtsEngineConfig& config) {
     }
 
     c.model.num_threads = config_.numThreads;
-    c.model.debug = 1;
-    c.model.provider = "cpu";
+    c.model.debug = config_.debug ? 1 : 0;
+    c.model.provider = config_.provider.c_str();
     c.rule_fsts = "";
     c.rule_fars = "";
     c.max_num_sentences = 1;

package/cpp/TtsEngine.hpp

@@ -45,6 +45,12 @@ struct TtsEngineConfig {
   int32_t outputSampleRate = 16000;
   int32_t speakerId = 0;
   float speed = 1.0f;
+  bool debug = false;
+#ifdef __APPLE__
+  std::string provider = "coreml";
+#else
+  std::string provider = "cpu";
+#endif
 };
 
 /** Native synthesis result (samples are kept as a float vector). */

package/cpp/Vad.cpp

@@ -53,6 +53,7 @@ std::shared_ptr<Promise<void>> Vad::initialize(const VadConfig& config) {
             .minSilenceDuration = static_cast<float>(config.minSilenceDurationMs.value_or(500.0)) / 1000.0f,
             .minSpeechDuration = static_cast<float>(config.minSpeechDurationMs.value_or(250.0)) / 1000.0f,
             .preBufferMs = static_cast<int32_t>(config.preBufferMs.value_or(300.0)),
+            .debug = config.debug.value_or(false),
         },
         shared_cast<Vad>());
   });

package/cpp/VadEngine.cpp

@@ -42,6 +42,7 @@ void VadEngine::initialize(const VadEngineConfig& config, std::shared_ptr<VadLis
   vadConfig.silero_vad.min_speech_duration = config_.minSpeechDuration;
   vadConfig.sample_rate = kSampleRate;
   vadConfig.num_threads = 1;
+  vadConfig.debug = config_.debug ? 1 : 0;
 
   // The second argument is the buffer size in milliseconds used internally by
   // sherpa-onnx. We reuse the configured pre-buffer duration.

package/cpp/VadEngine.hpp

@@ -34,6 +34,7 @@ struct VadEngineConfig {
   float minSilenceDuration = 0.5f;
   float minSpeechDuration = 0.25f;
   int32_t preBufferMs = 300;
+  bool debug = false;
 };
 
 /** One buffered or emitted speech segment with raw float samples. */

package/nitrogen/generated/shared/c++/AsrModelConfig.hpp

@@ -57,10 +57,12 @@ namespace margelo::nitro::onnx::speech {
     std::optional<double> maxActivePaths     SWIFT_PRIVATE;
     std::optional<std::string> language     SWIFT_PRIVATE;
     std::optional<bool> useItn     SWIFT_PRIVATE;
+    std::optional<bool> debug     SWIFT_PRIVATE;
+    std::optional<std::string> provider     SWIFT_PRIVATE;
 
   public:
     AsrModelConfig() = default;
-    explicit AsrModelConfig(AsrModelType type, std::string modelDir, std::string tokensPath, std::optional<std::string> whisperEncoder, std::optional<std::string> whisperDecoder, std::optional<std::string> encoder, std::optional<std::string> decoder, std::optional<std::string> joiner, std::optional<std::string> model, std::optional<std::string> config, std::optional<double> numThreads, std::optional<std::string> decodingMethod, std::optional<double> maxActivePaths, std::optional<std::string> language, std::optional<bool> useItn): type(type), modelDir(modelDir), tokensPath(tokensPath), whisperEncoder(whisperEncoder), whisperDecoder(whisperDecoder), encoder(encoder), decoder(decoder), joiner(joiner), model(model), config(config), numThreads(numThreads), decodingMethod(decodingMethod), maxActivePaths(maxActivePaths), language(language), useItn(useItn) {}
+    explicit AsrModelConfig(AsrModelType type, std::string modelDir, std::string tokensPath, std::optional<std::string> whisperEncoder, std::optional<std::string> whisperDecoder, std::optional<std::string> encoder, std::optional<std::string> decoder, std::optional<std::string> joiner, std::optional<std::string> model, std::optional<std::string> config, std::optional<double> numThreads, std::optional<std::string> decodingMethod, std::optional<double> maxActivePaths, std::optional<std::string> language, std::optional<bool> useItn, std::optional<bool> debug, std::optional<std::string> provider): type(type), modelDir(modelDir), tokensPath(tokensPath), whisperEncoder(whisperEncoder), whisperDecoder(whisperDecoder), encoder(encoder), decoder(decoder), joiner(joiner), model(model), config(config), numThreads(numThreads), decodingMethod(decodingMethod), maxActivePaths(maxActivePaths), language(language), useItn(useItn), debug(debug), provider(provider) {}
 
   public:
     friend bool operator==(const AsrModelConfig& lhs, const AsrModelConfig& rhs) = default;
@@ -90,7 +92,9 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "decodingMethod"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maxActivePaths"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "language"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "useItn")))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "useItn"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::onnx::speech::AsrModelConfig& arg) {
@@ -110,6 +114,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "maxActivePaths"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.maxActivePaths));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "language"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.language));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "useItn"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.useItn));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "debug"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.debug));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "provider"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.provider));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -135,6 +141,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "maxActivePaths")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "language")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "useItn")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/HybridOnnxSpeechSpec.cpp

@@ -20,7 +20,7 @@ namespace margelo::nitro::onnx::speech {
       prototype.registerHybridMethod("createStreamingAsr", &HybridOnnxSpeechSpec::createStreamingAsr);
       prototype.registerHybridMethod("createTts", &HybridOnnxSpeechSpec::createTts);
       prototype.registerHybridMethod("createSpeakerManager", &HybridOnnxSpeechSpec::createSpeakerManager);
-      prototype.registerHybridMethod("isQualcommCpu", &HybridOnnxSpeechSpec::isQualcommCpu);
+      prototype.registerHybridMethod("getQualcommSoc", &HybridOnnxSpeechSpec::getQualcommSoc);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridOnnxSpeechSpec.hpp

@@ -68,7 +68,7 @@ namespace margelo::nitro::onnx::speech {
       virtual std::shared_ptr<HybridStreamingAsrSpec> createStreamingAsr() = 0;
       virtual std::shared_ptr<HybridTtsSpec> createTts() = 0;
       virtual std::shared_ptr<HybridSpeakerManagerSpec> createSpeakerManager() = 0;
-      virtual bool isQualcommCpu() = 0;
+      virtual std::string getQualcommSoc() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/TtsModelConfig.hpp

@@ -66,10 +66,12 @@ namespace margelo::nitro::onnx::speech {
     std::optional<double> outputSampleRate     SWIFT_PRIVATE;
     std::optional<double> speakerId     SWIFT_PRIVATE;
     std::optional<double> speed     SWIFT_PRIVATE;
+    std::optional<bool> debug     SWIFT_PRIVATE;
+    std::optional<std::string> provider     SWIFT_PRIVATE;
 
   public:
     TtsModelConfig() = default;
-    explicit TtsModelConfig(TtsModelType type, std::string modelDir, std::optional<std::string> model, std::optional<std::string> acousticModel, std::optional<std::string> vocoder, std::optional<std::string> tokens, std::optional<std::string> lexicon, std::optional<std::string> voices, std::optional<std::string> espeakNgData, std::optional<std::string> dictDir, std::optional<std::string> lmMain, std::optional<std::string> lmFlow, std::optional<std::string> textConditioner, std::optional<std::string> pocketEncoder, std::optional<std::string> pocketDecoder, std::optional<std::string> vocabJson, std::optional<std::string> tokenScoresJson, std::optional<std::string> zipvoiceEncoder, std::optional<std::string> zipvoiceDecoder, std::optional<std::string> config, std::optional<double> numThreads, std::optional<double> outputSampleRate, std::optional<double> speakerId, std::optional<double> speed): type(type), modelDir(modelDir), model(model), acousticModel(acousticModel), vocoder(vocoder), tokens(tokens), lexicon(lexicon), voices(voices), espeakNgData(espeakNgData), dictDir(dictDir), lmMain(lmMain), lmFlow(lmFlow), textConditioner(textConditioner), pocketEncoder(pocketEncoder), pocketDecoder(pocketDecoder), vocabJson(vocabJson), tokenScoresJson(tokenScoresJson), zipvoiceEncoder(zipvoiceEncoder), zipvoiceDecoder(zipvoiceDecoder), config(config), numThreads(numThreads), outputSampleRate(outputSampleRate), speakerId(speakerId), speed(speed) {}
+    explicit TtsModelConfig(TtsModelType type, std::string modelDir, std::optional<std::string> model, std::optional<std::string> acousticModel, std::optional<std::string> vocoder, std::optional<std::string> tokens, std::optional<std::string> lexicon, std::optional<std::string> voices, std::optional<std::string> espeakNgData, std::optional<std::string> dictDir, std::optional<std::string> lmMain, std::optional<std::string> lmFlow, std::optional<std::string> textConditioner, std::optional<std::string> pocketEncoder, std::optional<std::string> pocketDecoder, std::optional<std::string> vocabJson, std::optional<std::string> tokenScoresJson, std::optional<std::string> zipvoiceEncoder, std::optional<std::string> zipvoiceDecoder, std::optional<std::string> config, std::optional<double> numThreads, std::optional<double> outputSampleRate, std::optional<double> speakerId, std::optional<double> speed, std::optional<bool> debug, std::optional<std::string> provider): type(type), modelDir(modelDir), model(model), acousticModel(acousticModel), vocoder(vocoder), tokens(tokens), lexicon(lexicon), voices(voices), espeakNgData(espeakNgData), dictDir(dictDir), lmMain(lmMain), lmFlow(lmFlow), textConditioner(textConditioner), pocketEncoder(pocketEncoder), pocketDecoder(pocketDecoder), vocabJson(vocabJson), tokenScoresJson(tokenScoresJson), zipvoiceEncoder(zipvoiceEncoder), zipvoiceDecoder(zipvoiceDecoder), config(config), numThreads(numThreads), outputSampleRate(outputSampleRate), speakerId(speakerId), speed(speed), debug(debug), provider(provider) {}
 
   public:
     friend bool operator==(const TtsModelConfig& lhs, const TtsModelConfig& rhs) = default;
@@ -108,7 +110,9 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "numThreads"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "outputSampleRate"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speakerId"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speed")))
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speed"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::onnx::speech::TtsModelConfig& arg) {
@@ -137,6 +141,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "outputSampleRate"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.outputSampleRate));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "speakerId"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.speakerId));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "speed"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.speed));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "debug"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.debug));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "provider"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.provider));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -171,6 +177,8 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "outputSampleRate")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speakerId")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speed")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "provider")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/VadConfig.hpp

@@ -45,10 +45,11 @@ namespace margelo::nitro::onnx::speech {
     std::optional<double> minSilenceDurationMs     SWIFT_PRIVATE;
     std::optional<double> minSpeechDurationMs     SWIFT_PRIVATE;
     std::optional<double> preBufferMs     SWIFT_PRIVATE;
+    std::optional<bool> debug     SWIFT_PRIVATE;
 
   public:
     VadConfig() = default;
-    explicit VadConfig(std::optional<std::string> modelPath, std::optional<double> threshold, std::optional<double> minSilenceDurationMs, std::optional<double> minSpeechDurationMs, std::optional<double> preBufferMs): modelPath(modelPath), threshold(threshold), minSilenceDurationMs(minSilenceDurationMs), minSpeechDurationMs(minSpeechDurationMs), preBufferMs(preBufferMs) {}
+    explicit VadConfig(std::optional<std::string> modelPath, std::optional<double> threshold, std::optional<double> minSilenceDurationMs, std::optional<double> minSpeechDurationMs, std::optional<double> preBufferMs, std::optional<bool> debug): modelPath(modelPath), threshold(threshold), minSilenceDurationMs(minSilenceDurationMs), minSpeechDurationMs(minSpeechDurationMs), preBufferMs(preBufferMs), debug(debug) {}
 
   public:
     friend bool operator==(const VadConfig& lhs, const VadConfig& rhs) = default;
@@ -68,7 +69,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "threshold"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minSilenceDurationMs"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minSpeechDurationMs"))),
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "preBufferMs")))
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "preBufferMs"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::onnx::speech::VadConfig& arg) {
@@ -78,6 +80,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "minSilenceDurationMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.minSilenceDurationMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "minSpeechDurationMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.minSpeechDurationMs));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "preBufferMs"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.preBufferMs));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "debug"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.debug));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -93,6 +96,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minSilenceDurationMs")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "minSpeechDurationMs")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "preBufferMs")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-onnx",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "React Native Nitro module wrapping sherpa-onnx for local ASR, TTS, VAD and voice cloning",
   "license": "MIT",
   "homepage": "https://github.com/zydbkqf/react-native-nitro-onnx",

package/src/specs/OnnxSpeech.nitro.ts

@@ -47,6 +47,8 @@ export interface VadConfig {
   minSpeechDurationMs?: number;
   /** How many milliseconds of audio to keep before onSpeechStart. Default: 300. */
   preBufferMs?: number;
+  /** Enable sherpa-onnx debug logging for this model. Default: false. */
+  debug?: boolean;
 }
 
 /** VAD segment delivered after speech ends or on explicit pull. */
@@ -130,6 +132,15 @@ export interface AsrModelConfig {
   language?: string;
   /** SenseVoice: whether to use itn. */
   useItn?: boolean;
+  /** Enable sherpa-onnx debug logging for this model. Default: false. */
+  debug?: boolean;
+  /**
+   * Execution provider for ONNX Runtime.
+   * Default: "qnn" on Android (Qualcomm NPU, unsupported ops fall back to CPU),
+   *          "coreml" on iOS (Apple Neural Engine, unsupported ops fall back to CPU).
+   * Pass "cpu" explicitly to disable NPU acceleration.
+   */
+  provider?: string;
 }
 
 export interface AsrResult {
@@ -243,6 +254,15 @@ export interface TtsModelConfig {
   speakerId?: number;
   /** Speed factor, e.g. 1.0. */
   speed?: number;
+  /** Enable sherpa-onnx debug logging for this model. Default: false. */
+  debug?: boolean;
+  /**
+   * Execution provider for ONNX Runtime.
+   * Default: "qnn" on Android (Qualcomm NPU, unsupported ops fall back to CPU),
+   *          "coreml" on iOS (Apple Neural Engine, unsupported ops fall back to CPU).
+   * Pass "cpu" explicitly to disable NPU acceleration.
+   */
+  provider?: string;
 }
 
 export interface TtsResult {
@@ -321,6 +341,6 @@ export interface OnnxSpeech extends HybridObject<SpeechPlatforms> {
   createSpeakerManager(): SpeakerManager;
   /** Get the module version. */
   readonly version: string;
-  /** Check if the CPU is a Qualcomm chip. Always returns false on iOS. */
-  isQualcommCpu(): boolean;
+  /** Returns the Qualcomm SoC model (e.g. "SM8550") on Android, or empty string on iOS / non-Qualcomm. */
+  getQualcommSoc(): string;
 }