react-native-nitro-onnx 0.1.0 → 0.1.2

package/cpp/AsrEngine.cpp

@@ -6,8 +6,8 @@
 #include "AudioFileReader.hpp"
 #include "sherpa-onnx/c-api/c-api.h"
 
+#include <cmath>
 #include <cstring>
-#include <fstream>
 #include <stdexcept>
 
 namespace margelo::nitro::onnx::speech {
@@ -33,25 +33,74 @@ std::string joinPath(const std::string& dir, const std::string& file) {
 ModelSingleton<const SherpaOnnxOfflineRecognizer> gOfflineRecognizerCache;
 ModelSingleton<const SherpaOnnxOnlineRecognizer> gOnlineRecognizerCache;
 
+float meanTokenConfidence(const float* logProbs, int32_t count) {
+  if (logProbs == nullptr || count <= 0) {
+    return 0.0f;
+  }
+  double sum = 0.0;
+  for (int32_t i = 0; i < count; ++i) {
+    sum += logProbs[i];
+  }
+  return static_cast<float>(std::exp(sum / count));
+}
+
+void fillTimestampsMs(AsrEngineResult& result, const float* timestamps, int32_t count) {
+  if (timestamps == nullptr || count <= 0) {
+    return;
+  }
+  result.timestamps.assign(timestamps, timestamps + count);
+  for (float& t : result.timestamps) {
+    t *= 1000.0f;
+  }
+  if (!result.timestamps.empty()) {
+    result.startMs = result.timestamps.front();
+  }
+}
+
+AsrEngineResult fromOfflineResult(const SherpaOnnxOfflineRecognizerResult& r, float endMs) {
+  AsrEngineResult result;
+  result.text = r.text ? r.text : "";
+  result.endMs = endMs;
+  result.score = meanTokenConfidence(r.ys_log_probs, r.count);
+  fillTimestampsMs(result, r.timestamps, r.count);
+  if (r.json) {
+    result.json = r.json;
+  }
+  return result;
+}
+
+AsrEngineResult fromOnlineResult(const SherpaOnnxOnlineRecognizerResult& r) {
+  AsrEngineResult result;
+  result.text = r.text ? r.text : "";
+  fillTimestampsMs(result, r.timestamps, r.count);
+  if (r.json) {
+    result.json = r.json;
+  }
+  return result;
+}
+
 }  // namespace
 
+std::string AsrEngineConfig::cacheSignature() const {
+  return modelDir + "|" + std::to_string(static_cast<int>(type)) + "|" + provider + "|" +
+         std::to_string(numThreads) + "|" + language + "|" + decodingMethod + "|" +
+         std::to_string(maxActivePaths) + "|" + (useItn ? "1" : "0");
+}
+
 // ------------------------------------------------------------------------------
 // Offline ASR
 // ------------------------------------------------------------------------------
 
-OfflineAsrEngine::OfflineAsrEngine(std::shared_ptr<ThreadPool> threadPool)
-    : threadPool_(std::move(threadPool)) {}
-
 OfflineAsrEngine::~OfflineAsrEngine() {
   unload();
 }
 
 void OfflineAsrEngine::load(const AsrEngineConfig& config) {
   unload();
+  std::lock_guard<std::mutex> lock(mutex_);
   config_ = config;
 
-  const std::string key = config_.modelDir + "|" + std::to_string(static_cast<int>(config_.type));
-  auto cached = gOfflineRecognizerCache.getOrCreate(key, [this](const std::string&) {
+  auto cached = gOfflineRecognizerCache.getOrCreate(config_.cacheSignature(), [this](const std::string&) {
     SherpaOnnxOfflineRecognizerConfig c;
     std::memset(&c, 0, sizeof(c));
 
@@ -70,6 +119,7 @@ void OfflineAsrEngine::load(const AsrEngineConfig& config) {
         c.model_config.whisper.decoder = whisperDecoder.c_str();
         c.model_config.whisper.language = config_.language.c_str();
         c.model_config.whisper.tail_paddings = 2;
+        c.model_config.model_type = "whisper";
         break;
       case AsrModelType::TRANSDUCER:
       case AsrModelType::ZIPFORMER:
@@ -79,24 +129,51 @@ void OfflineAsrEngine::load(const AsrEngineConfig& config) {
         c.model_config.transducer.joiner = joiner.c_str();
         break;
       case AsrModelType::PARAFORMER:
+        c.model_config.paraformer.model = model.c_str();
+        c.model_config.model_type = "paraformer";
+        break;
       case AsrModelType::WENET:
+        c.model_config.wenet_ctc.model = model.c_str();
+        c.model_config.model_type = "wenet_ctc";
+        break;
       case AsrModelType::TELESPEECH:
+        c.model_config.telespeech_ctc = model.c_str();
+        c.model_config.model_type = "telespeech_ctc";
+        break;
       case AsrModelType::SENSE_VOICE:
-        c.model_config.paraformer.model = model.c_str();
+        c.model_config.sense_voice.model = model.c_str();
+        c.model_config.sense_voice.language = config_.language.c_str();
+        c.model_config.sense_voice.use_itn = config_.useItn ? 1 : 0;
+        c.model_config.model_type = "sense_voice";
         break;
       case AsrModelType::MOONSHINE:
+        // Moonshine layout: model=preprocessor, encoder=encoder,
+        // decoder=uncached_decoder (or merged_decoder when joiner is empty),
+        // joiner=cached_decoder.
+        c.model_config.moonshine.preprocessor = model.c_str();
+        c.model_config.moonshine.encoder = encoder.c_str();
+        if (joiner.empty()) {
+          c.model_config.moonshine.merged_decoder = decoder.c_str();
+        } else {
+          c.model_config.moonshine.uncached_decoder = decoder.c_str();
+          c.model_config.moonshine.cached_decoder = joiner.c_str();
+        }
+        c.model_config.model_type = "moonshine";
+        break;
       case AsrModelType::DOLPHIN:
+        c.model_config.dolphin.model = model.c_str();
+        c.model_config.model_type = "dolphin";
+        break;
       case AsrModelType::NEMO:
         c.model_config.nemo_ctc.model = model.c_str();
-        if (config_.type == AsrModelType::NEMO) {
-          c.model_config.model_type = "nemo";
-        }
+        c.model_config.model_type = "nemo";
         break;
     }
 
     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;
 
@@ -112,34 +189,34 @@ void OfflineAsrEngine::load(const AsrEngineConfig& config) {
 }
 
 bool OfflineAsrEngine::isLoaded() const {
+  std::lock_guard<std::mutex> lock(mutex_);
   return recognizer_ != nullptr;
 }
 
 AsrEngineResult OfflineAsrEngine::recognize(const std::vector<float>& samples) {
-  if (recognizer_ == nullptr) {
+  // Copy the shared_ptr under the lock, then decode without holding it so
+  // concurrent recognize() calls can share the same const recognizer.
+  std::shared_ptr<const SherpaOnnxOfflineRecognizer> recognizer;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    recognizer = recognizer_;
+  }
+  if (recognizer == nullptr) {
     throw std::runtime_error("Offline ASR not loaded");
   }
 
-  const SherpaOnnxOfflineStream* stream = SherpaOnnxCreateOfflineStream(recognizer_.get());
+  const SherpaOnnxOfflineStream* stream = SherpaOnnxCreateOfflineStream(recognizer.get());
   SherpaOnnxAcceptWaveformOffline(stream, 16000, samples.data(), static_cast<int32_t>(samples.size()));
-  SherpaOnnxDecodeOfflineStream(recognizer_.get(), stream);
+  SherpaOnnxDecodeOfflineStream(recognizer.get(), stream);
 
-  const char* json = SherpaOnnxGetOfflineStreamResultAsJson(stream);
+  const SherpaOnnxOfflineRecognizerResult* raw = SherpaOnnxGetOfflineStreamResult(stream);
   AsrEngineResult result;
-  result.json = json ? json : "";
-
-  // Parse the JSON to extract text. In a full implementation, use a JSON
-  // library to also populate timestamps and score.
-  const char* textKey = "\"text\":\"";
-  const char* textStart = std::strstr(result.json.c_str(), textKey);
-  if (textStart != nullptr) {
-    textStart += std::strlen(textKey);
-    const char* textEnd = std::strstr(textStart, "\"");
-    if (textEnd != nullptr) {
-      result.text = std::string(textStart, textEnd);
-    }
+  if (raw != nullptr) {
+    result = fromOfflineResult(*raw, samplesToMs(static_cast<int32_t>(samples.size())));
+    SherpaOnnxDestroyOfflineRecognizerResult(raw);
+  } else {
+    result.endMs = samplesToMs(static_cast<int32_t>(samples.size()));
   }
-  result.endMs = samplesToMs(static_cast<int32_t>(samples.size()));
 
   SherpaOnnxDestroyOfflineStream(stream);
   return result;
@@ -156,6 +233,7 @@ AsrEngineResult OfflineAsrEngine::recognizeFile(const std::string& path) {
 }
 
 void OfflineAsrEngine::unload() {
+  std::lock_guard<std::mutex> lock(mutex_);
   recognizer_.reset();
 }
 
@@ -163,9 +241,6 @@ void OfflineAsrEngine::unload() {
 // Streaming ASR
 // ------------------------------------------------------------------------------
 
-StreamingAsrEngine::StreamingAsrEngine(std::shared_ptr<ThreadPool> threadPool)
-    : threadPool_(std::move(threadPool)) {}
-
 StreamingAsrEngine::~StreamingAsrEngine() {
   unload();
 }
@@ -174,10 +249,11 @@ void StreamingAsrEngine::load(
     const AsrEngineConfig& config,
     std::shared_ptr<StreamingAsrListener> listener) {
   unload();
+  std::lock_guard<std::mutex> lock(mutex_);
   config_ = config;
   listener_ = std::move(listener);
 
-  const std::string key = config_.modelDir + "|streaming|" + std::to_string(static_cast<int>(config_.type));
+  const std::string key = config_.cacheSignature() + "|streaming";
   auto cached = gOnlineRecognizerCache.getOrCreate(key, [this](const std::string&) {
     SherpaOnnxOnlineRecognizerConfig c;
     std::memset(&c, 0, sizeof(c));
@@ -196,11 +272,13 @@ void StreamingAsrEngine::load(
         c.model_config.transducer.joiner = joiner.c_str();
         break;
       default:
-        throw std::runtime_error("Streaming ASR does not support this model type in the scaffold");
+        throw std::runtime_error("Streaming ASR only supports transducer / zipformer / conformer models");
     }
 
     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;
@@ -219,48 +297,64 @@ void StreamingAsrEngine::load(
 }
 
 bool StreamingAsrEngine::isLoaded() const {
+  std::lock_guard<std::mutex> lock(mutex_);
   return recognizer_ != nullptr && stream_ != nullptr;
 }
 
 void StreamingAsrEngine::acceptWaveform(const std::vector<float>& samples) {
-  if (recognizer_ == nullptr || stream_ == nullptr) {
-    throw std::runtime_error("Streaming ASR not loaded");
-  }
-  SherpaOnnxOnlineStreamAcceptWaveform(stream_.get(), 16000, samples.data(), static_cast<int32_t>(samples.size()));
-
-  if (listener_ && SherpaOnnxIsOnlineStreamReady(recognizer_.get(), stream_.get())) {
-    SherpaOnnxDecodeOnlineStream(recognizer_.get(), stream_.get());
-    const char* json = SherpaOnnxGetOnlineStreamResultAsJson(recognizer_.get(), stream_.get());
-    if (json != nullptr) {
-      AsrEngineResult result;
-      result.json = json;
-      // TODO: parse text from JSON.
-      listener_->onPartialResult(result);
-      SherpaOnnxDestroyOnlineStreamResultJson(json);
+  std::shared_ptr<StreamingAsrListener> listener;
+  AsrEngineResult result;
+  bool hasResult = false;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (recognizer_ == nullptr || stream_ == nullptr) {
+      throw std::runtime_error("Streaming ASR not loaded");
+    }
+    SherpaOnnxOnlineStreamAcceptWaveform(stream_.get(), 16000, samples.data(), static_cast<int32_t>(samples.size()));
+
+    if (SherpaOnnxIsOnlineStreamReady(recognizer_.get(), stream_.get())) {
+      SherpaOnnxDecodeOnlineStream(recognizer_.get(), stream_.get());
+      const SherpaOnnxOnlineRecognizerResult* raw =
+          SherpaOnnxGetOnlineStreamResult(recognizer_.get(), stream_.get());
+      if (raw != nullptr) {
+        result = fromOnlineResult(*raw);
+        SherpaOnnxDestroyOnlineRecognizerResult(raw);
+        hasResult = true;
+      }
     }
+    listener = listener_.lock();
+  }
+  if (hasResult && listener) {
+    listener->onPartialResult(result);
   }
 }
 
 AsrEngineResult StreamingAsrEngine::finalize() {
-  if (recognizer_ == nullptr || stream_ == nullptr) {
-    throw std::runtime_error("Streaming ASR not loaded");
-  }
-  SherpaOnnxOnlineStreamInputFinished(stream_.get());
-  SherpaOnnxDecodeOnlineStream(recognizer_.get(), stream_.get());
-  const char* json = SherpaOnnxGetOnlineStreamResultAsJson(recognizer_.get(), stream_.get());
+  std::shared_ptr<StreamingAsrListener> listener;
   AsrEngineResult result;
-  if (json != nullptr) {
-    result.json = json;
-    // TODO: parse text from JSON.
-    SherpaOnnxDestroyOnlineStreamResultJson(json);
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (recognizer_ == nullptr || stream_ == nullptr) {
+      throw std::runtime_error("Streaming ASR not loaded");
+    }
+    SherpaOnnxOnlineStreamInputFinished(stream_.get());
+    SherpaOnnxDecodeOnlineStream(recognizer_.get(), stream_.get());
+    const SherpaOnnxOnlineRecognizerResult* raw =
+        SherpaOnnxGetOnlineStreamResult(recognizer_.get(), stream_.get());
+    if (raw != nullptr) {
+      result = fromOnlineResult(*raw);
+      SherpaOnnxDestroyOnlineRecognizerResult(raw);
+    }
+    listener = listener_.lock();
   }
-  if (listener_) {
-    listener_->onFinalResult(result);
+  if (listener) {
+    listener->onFinalResult(result);
   }
   return result;
 }
 
 void StreamingAsrEngine::reset() {
+  std::lock_guard<std::mutex> lock(mutex_);
   if (recognizer_ != nullptr) {
     stream_ = std::shared_ptr<const SherpaOnnxOnlineStream>(
         SherpaOnnxCreateOnlineStream(recognizer_.get()),
@@ -269,6 +363,7 @@ void StreamingAsrEngine::reset() {
 }
 
 void StreamingAsrEngine::unload() {
+  std::lock_guard<std::mutex> lock(mutex_);
   stream_.reset();
   recognizer_.reset();
   listener_.reset();

package/cpp/AsrEngine.hpp

@@ -9,11 +9,11 @@
 
 #include "AudioUtils.hpp"
 #include "ModelSingleton.hpp"
-#include "ThreadPool.hpp"
 
 #include "AsrModelType.hpp"
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -41,6 +41,19 @@ struct AsrEngineConfig {
   int32_t maxActivePaths = 4;
   std::string language = "en";
   bool useItn = true;
+  bool debug = false;
+#if defined(__ANDROID__) && defined(SHERPA_ONNX_ENABLE_QNN)
+  std::string provider = "qnn";
+#elif defined(__ANDROID__)
+  std::string provider = "nnapi";
+#elif defined(__APPLE__)
+  std::string provider = "coreml";
+#else
+  std::string provider = "cpu";
+#endif
+
+  /** Cache-key signature covering options that change recognizer identity. */
+  std::string cacheSignature() const;
 };
 
 /** Native recognition result before conversion to the generated AsrResult. */
@@ -65,7 +78,7 @@ class StreamingAsrListener {
 /** Offline ASR engine. */
 class OfflineAsrEngine final {
  public:
-  explicit OfflineAsrEngine(std::shared_ptr<ThreadPool> threadPool);
+  OfflineAsrEngine() = default;
   ~OfflineAsrEngine();
 
   OfflineAsrEngine(const OfflineAsrEngine&) = delete;
@@ -78,7 +91,7 @@ class OfflineAsrEngine final {
   void unload();
 
  private:
-  std::shared_ptr<ThreadPool> threadPool_;
+  mutable std::mutex mutex_;
   AsrEngineConfig config_;
   std::shared_ptr<const SherpaOnnxOfflineRecognizer> recognizer_;
 };
@@ -86,7 +99,7 @@ class OfflineAsrEngine final {
 /** Streaming ASR engine. */
 class StreamingAsrEngine final {
  public:
-  explicit StreamingAsrEngine(std::shared_ptr<ThreadPool> threadPool);
+  StreamingAsrEngine() = default;
   ~StreamingAsrEngine();
 
   StreamingAsrEngine(const StreamingAsrEngine&) = delete;
@@ -100,9 +113,9 @@ class StreamingAsrEngine final {
   void unload();
 
  private:
-  std::shared_ptr<ThreadPool> threadPool_;
+  mutable std::mutex mutex_;
   AsrEngineConfig config_;
-  std::shared_ptr<StreamingAsrListener> listener_;
+  std::weak_ptr<StreamingAsrListener> listener_;
   std::shared_ptr<const SherpaOnnxOnlineRecognizer> recognizer_;
   std::shared_ptr<const SherpaOnnxOnlineStream> stream_;
 };

package/cpp/AudioFileReader.cpp

@@ -3,6 +3,7 @@
 // ------------------------------------------------------------------------------
 #include "AudioFileReader.hpp"
 
+#include <bit>
 #include <cmath>
 #include <cstring>
 #include <fstream>
@@ -12,6 +13,9 @@ namespace margelo::nitro::onnx::speech {
 
 namespace {
 
+static_assert(std::endian::native == std::endian::little,
+              "WAV reader assumes little-endian targets");
+
 constexpr int32_t kTargetSampleRate = 16000;
 
 struct WavHeader {

package/cpp/ModelSingleton.hpp

@@ -16,6 +16,9 @@ namespace margelo::nitro::onnx::speech {
 
 /**
  * Thread-safe cache for heavy model instances.
+ * The cache key must cover every config field that changes model identity
+ * (paths, provider, thread count, language, ...), otherwise a later load with
+ * different options would incorrectly reuse the first instance.
  * @tparam T The native model type (e.g. SherpaOnnxOfflineRecognizer).
  */
 template <typename T>
@@ -26,6 +29,7 @@ class ModelSingleton final {
   /** Return a cached instance or create one using factory. */
   std::shared_ptr<T> getOrCreate(const std::string& key, const Factory& factory) {
     std::lock_guard<std::mutex> lock(mutex_);
+    pruneExpiredLocked();
     auto it = instances_.find(key);
     if (it != instances_.end()) {
       if (auto alive = it->second.lock()) {
@@ -44,6 +48,16 @@ class ModelSingleton final {
   }
 
  private:
+  void pruneExpiredLocked() {
+    for (auto it = instances_.begin(); it != instances_.end();) {
+      if (it->second.expired()) {
+        it = instances_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
   std::mutex mutex_;
   std::unordered_map<std::string, std::weak_ptr<T>> instances_;
 };

package/cpp/NitroOnnxSpeech.cpp

@@ -9,60 +9,79 @@
 #include "StreamingAsr.hpp"
 #include "Tts.hpp"
 #include "Vad.hpp"
+#include "Version.hpp"
 
 #include <cstdio>
 #include <cstring>
 
+#ifdef __ANDROID__
+#include <sys/system_properties.h>
+#endif
+
 namespace margelo::nitro::onnx::speech {
 
 NitroOnnxSpeech::NitroOnnxSpeech()
-    : HybridObject(TAG),
-      threadPool_(std::make_shared<ThreadPool>()),
-      cacheDir_(getCacheDir()) {}
+    : HybridObject(TAG) {}
 
 NitroOnnxSpeech::~NitroOnnxSpeech() = default;
 
 std::shared_ptr<HybridVadSpec> NitroOnnxSpeech::createVad() {
-  return std::make_shared<Vad>(threadPool_);
+  return std::make_shared<Vad>();
 }
 
 std::shared_ptr<HybridOfflineAsrSpec> NitroOnnxSpeech::createOfflineAsr() {
-  return std::make_shared<OfflineAsr>(threadPool_);
+  return std::make_shared<OfflineAsr>();
 }
 
 std::shared_ptr<HybridStreamingAsrSpec> NitroOnnxSpeech::createStreamingAsr() {
-  return std::make_shared<StreamingAsr>(threadPool_);
+  return std::make_shared<StreamingAsr>();
 }
 
 std::shared_ptr<HybridTtsSpec> NitroOnnxSpeech::createTts() {
-  return std::make_shared<Tts>(threadPool_);
+  return std::make_shared<Tts>();
 }
 
 std::shared_ptr<HybridSpeakerManagerSpec> NitroOnnxSpeech::createSpeakerManager() {
-  return std::make_shared<SpeakerManager>(threadPool_, cacheDir_);
+  return std::make_shared<SpeakerManager>();
 }
 
 std::string NitroOnnxSpeech::getVersion() {
-  return "0.1.0";
+  return NITRO_ONNX_SPEECH_VERSION;
 }
 
-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

@@ -4,8 +4,6 @@
 // ------------------------------------------------------------------------------
 #pragma once
 
-#include "ThreadPool.hpp"
-
 #include <NitroModules/HybridObject.hpp>
 #include <HybridOnnxSpeechSpec.hpp>
 #include <HybridOfflineAsrSpec.hpp>
@@ -32,11 +30,7 @@ class NitroOnnxSpeech : public HybridOnnxSpeechSpec {
   std::shared_ptr<HybridTtsSpec> createTts() override;
   std::shared_ptr<HybridSpeakerManagerSpec> createSpeakerManager() override;
   std::string getVersion() override;
-  bool isQualcommCpu() override;
-
- private:
-  std::shared_ptr<ThreadPool> threadPool_;
-  std::string cacheDir_;
+  std::string getQualcommSoc() override;
 };
 
 }  // namespace margelo::nitro::onnx::speech

package/cpp/OfflineAsr.cpp

@@ -28,15 +28,14 @@ AsrResult toAsrResult(const AsrEngineResult& native) {
 
 }  // namespace
 
-OfflineAsr::OfflineAsr(std::shared_ptr<ThreadPool> threadPool)
-    : HybridObject(TAG), engine_(std::move(threadPool)) {}
+OfflineAsr::OfflineAsr() : HybridObject(TAG) {}
 
 OfflineAsr::~OfflineAsr() {
   engine_.unload();
 }
 
 std::shared_ptr<Promise<void>> OfflineAsr::load(const AsrModelConfig& config) {
-  return Promise<void>::async([this, config]() {
+  return Promise<void>::async([self = shared_cast<OfflineAsr>(), config]() {
     AsrEngineConfig native;
     native.type = config.type;
     native.modelDir = config.modelDir;
@@ -53,7 +52,17 @@ 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);
-    engine_.load(native);
+    native.debug = config.debug.value_or(false);
+#if defined(__ANDROID__) && defined(SHERPA_ONNX_ENABLE_QNN)
+    native.provider = config.provider.value_or("qnn");
+#elif defined(__ANDROID__)
+    native.provider = config.provider.value_or("nnapi");
+#elif defined(__APPLE__)
+    native.provider = config.provider.value_or("coreml");
+#else
+    native.provider = config.provider.value_or("cpu");
+#endif
+    self->engine_.load(native);
   });
 }
 
@@ -63,19 +72,19 @@ bool OfflineAsr::isLoaded() {
 
 std::shared_ptr<Promise<AsrResult>> OfflineAsr::recognize(
     const std::shared_ptr<ArrayBuffer>& samples) {
-  return Promise<AsrResult>::async([this, samples]() {
+  return Promise<AsrResult>::async([self = shared_cast<OfflineAsr>(), samples]() {
     auto floatSamples = bytesToFloatVector(samples->data(), samples->size());
-    return toAsrResult(engine_.recognize(floatSamples));
+    return toAsrResult(self->engine_.recognize(floatSamples));
   });
 }
 
 std::shared_ptr<Promise<AsrResult>> OfflineAsr::recognizeFile(const std::string& path) {
   return Promise<AsrResult>::async(
-      [this, path]() { return toAsrResult(engine_.recognizeFile(path)); });
+      [self = shared_cast<OfflineAsr>(), path]() { return toAsrResult(self->engine_.recognizeFile(path)); });
 }
 
 std::shared_ptr<Promise<void>> OfflineAsr::unload() {
-  return Promise<void>::async([this]() { engine_.unload(); });
+  return Promise<void>::async([self = shared_cast<OfflineAsr>()]() { self->engine_.unload(); });
 }
 
 }  // namespace margelo::nitro::onnx::speech

package/cpp/OfflineAsr.hpp

@@ -17,7 +17,7 @@ class OfflineAsr : public HybridOfflineAsrSpec {
  public:
   static constexpr auto TAG = "OfflineAsr";
 
-  explicit OfflineAsr(std::shared_ptr<ThreadPool> threadPool);
+  OfflineAsr();
   ~OfflineAsr() override;
 
   std::shared_ptr<Promise<void>> load(const AsrModelConfig& config) override;