react-native-nitro-onnx 0.1.1 → 0.1.2

package/src/specs/OnnxSpeech.nitro.ts

@@ -118,7 +118,12 @@ export interface AsrModelConfig {
   encoder?: string;
   decoder?: string;
   joiner?: string;
-  /** Paraformer / Wenet / Telespeech / SenseVoice: single model file. */
+  /**
+   * Single-model families (Paraformer / Wenet / Telespeech / Dolphin / NeMo / SenseVoice).
+   * Moonshine: `model` is preprocessor.onnx, `encoder` is encoder.onnx,
+   * `decoder` is uncached_decoder.onnx (or merged_decoder.onnx when `joiner` is unset),
+   * `joiner` is cached_decoder.onnx.
+   */
   model?: string;
   /** NeMo config file (.yaml). */
   config?: string;
@@ -136,7 +141,7 @@ export interface AsrModelConfig {
   debug?: boolean;
   /**
    * Execution provider for ONNX Runtime.
-   * Default: "qnn" on Android (Qualcomm NPU, unsupported ops fall back to CPU),
+   * Default: "nnapi" on Android (or "qnn" when built with -DQNN_ROOT),
    *          "coreml" on iOS (Apple Neural Engine, unsupported ops fall back to CPU).
    * Pass "cpu" explicitly to disable NPU acceleration.
    */
@@ -258,9 +263,8 @@ export interface TtsModelConfig {
   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.
+   * Default: "cpu" on Android / Linux, "coreml" on iOS.
+   * Pass a provider explicitly to enable NPU acceleration.
    */
   provider?: string;
 }
@@ -279,7 +283,13 @@ export interface Tts extends HybridObject<SpeechPlatforms> {
   isLoaded(): boolean;
   /** Synthesize text into audio on a background thread. Optional speed override. */
   synthesize(text: string, speed?: number): Promise<TtsResult>;
-  /** Synthesize with a cloned speaker embedding (reference-audio cloning). */
+  /**
+   * Synthesize with a speaker reference.
+   * `speakerId` is either a numeric model speaker index ("0", "1", ... for
+   * Kokoro/VITS multi-speaker) or a registered speaker ID from
+   * `registerSpeaker` / `registerSpeakerFromFile` (zero-shot models such as
+   * Pocket require the reference audio stored by `registerSpeakerFromFile`).
+   */
   synthesizeWithSpeaker(text: string, speakerId: string, speed?: number): Promise<TtsResult>;
   /** Save TTS result as a WAV file at the given path. */
   saveWav(result: TtsResult, path: string): Promise<void>;
@@ -313,9 +323,16 @@ export interface SpeakerManager extends HybridObject<SpeechPlatforms> {
   isLoaded(): boolean;
   /** Compute an embedding from reference 16 kHz mono f32 PCM audio. */
   computeEmbedding(samples: ArrayBuffer): Promise<ArrayBuffer>;
-  /** Register a speaker embedding for later TTS use. */
+  /**
+   * Register a speaker embedding for later TTS use.
+   * Note: embedding-only records cannot drive zero-shot TTS; use
+   * `registerSpeakerFromFile` when you need voice cloning with Pocket.
+   */
   registerSpeaker(id: string, name: string, embedding: ArrayBuffer): Promise<RegisteredSpeaker>;
-  /** Register from a reference audio file. */
+  /**
+   * Register from a reference audio file. Stores both the speaker embedding
+   * and the reference audio required by zero-shot TTS models.
+   */
   registerSpeakerFromFile(id: string, name: string, path: string): Promise<RegisteredSpeaker>;
   /** List registered speakers. */
   listSpeakers(): Promise<RegisteredSpeaker[]>;

package/cpp/ThreadPool.cpp

@@ -1,41 +0,0 @@
-// ------------------------------------------------------------------------------
-// ThreadPool.cpp
-// ------------------------------------------------------------------------------
-#include "ThreadPool.hpp"
-
-namespace margelo::nitro::onnx::speech {
-
-ThreadPool::ThreadPool(size_t threadCount) {
-  for (size_t i = 0; i < threadCount; ++i) {
-    workers_.emplace_back([this]() {
-      for (;;) {
-        std::function<void()> task;
-        {
-          std::unique_lock<std::mutex> lock(queueMutex_);
-          condition_.wait(lock, [this]() { return stop_ || !tasks_.empty(); });
-          if (stop_ && tasks_.empty()) {
-            return;
-          }
-          task = std::move(tasks_.front());
-          tasks_.pop();
-        }
-        task();
-      }
-    });
-  }
-}
-
-ThreadPool::~ThreadPool() {
-  {
-    std::unique_lock<std::mutex> lock(queueMutex_);
-    stop_ = true;
-  }
-  condition_.notify_all();
-  for (std::thread& worker : workers_) {
-    if (worker.joinable()) {
-      worker.join();
-    }
-  }
-}
-
-}  // namespace margelo::nitro::onnx::speech

package/cpp/ThreadPool.hpp

@@ -1,62 +0,0 @@
-// ------------------------------------------------------------------------------
-// ThreadPool.hpp
-// A fixed-size thread pool used to run all heavy native inference tasks.
-// Keeping inference off the JS thread is a core requirement of this module.
-// ------------------------------------------------------------------------------
-#pragma once
-
-#include <atomic>
-#include <condition_variable>
-#include <functional>
-#include <future>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
-
-namespace margelo::nitro::onnx::speech {
-
-/**
- * Minimal thread pool for background inference work.
- * Tasks are enqueued as std::function<void()> and executed by worker threads.
- */
-class ThreadPool final {
- public:
-  explicit ThreadPool(size_t threadCount = std::thread::hardware_concurrency());
-  ~ThreadPool();
-
-  ThreadPool(const ThreadPool&) = delete;
-  ThreadPool& operator=(const ThreadPool&) = delete;
-
-  /**
-   * Schedule a task on the pool and obtain a future for the result.
-   * @tparam F Callable type.
-   * @tparam Args Argument types.
-   * @return std::future for the callable result.
-   */
-  template <typename F, typename... Args>
-  auto enqueue(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>> {
-    using ReturnType = std::invoke_result_t<F, Args...>;
-    auto task = std::make_shared<std::packaged_task<ReturnType()>>(
-        std::bind(std::forward<F>(f), std::forward<Args>(args)...));
-    std::future<ReturnType> result = task->get_future();
-    {
-      std::unique_lock<std::mutex> lock(queueMutex_);
-      if (stop_) {
-        throw std::runtime_error("Cannot enqueue on stopped ThreadPool");
-      }
-      tasks_.emplace([task]() { (*task)(); });
-    }
-    condition_.notify_one();
-    return result;
-  }
-
- private:
-  std::vector<std::thread> workers_;
-  std::queue<std::function<void()>> tasks_;
-  std::mutex queueMutex_;
-  std::condition_variable condition_;
-  std::atomic<bool> stop_{false};
-};
-
-}  // namespace margelo::nitro::onnx::speech