react-native-nitro-onnx 0.1.0

package/cpp/ModelSingleton.hpp

@@ -0,0 +1,51 @@
+// ------------------------------------------------------------------------------
+// ModelSingleton.hpp
+// Heavy AI models are expensive to initialize. This template keeps at most one
+// instance of a model per configuration key so repeated create/load calls reuse
+// the same native object.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace margelo::nitro::onnx::speech {
+
+/**
+ * Thread-safe cache for heavy model instances.
+ * @tparam T The native model type (e.g. SherpaOnnxOfflineRecognizer).
+ */
+template <typename T>
+class ModelSingleton final {
+ public:
+  using Factory = std::function<std::shared_ptr<T>(const std::string& key)>;
+
+  /** 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_);
+    auto it = instances_.find(key);
+    if (it != instances_.end()) {
+      if (auto alive = it->second.lock()) {
+        return alive;
+      }
+    }
+    auto created = factory(key);
+    instances_[key] = created;
+    return created;
+  }
+
+  /** Invalidate all cached instances. */
+  void clear() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    instances_.clear();
+  }
+
+ private:
+  std::mutex mutex_;
+  std::unordered_map<std::string, std::weak_ptr<T>> instances_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/NitroOnnxSpeech.cpp

@@ -0,0 +1,68 @@
+// ------------------------------------------------------------------------------
+// NitroOnnxSpeech.cpp
+// ------------------------------------------------------------------------------
+#include "NitroOnnxSpeech.hpp"
+
+#include "OfflineAsr.hpp"
+#include "ResourceDir.hpp"
+#include "SpeakerManager.hpp"
+#include "StreamingAsr.hpp"
+#include "Tts.hpp"
+#include "Vad.hpp"
+
+#include <cstdio>
+#include <cstring>
+
+namespace margelo::nitro::onnx::speech {
+
+NitroOnnxSpeech::NitroOnnxSpeech()
+    : HybridObject(TAG),
+      threadPool_(std::make_shared<ThreadPool>()),
+      cacheDir_(getCacheDir()) {}
+
+NitroOnnxSpeech::~NitroOnnxSpeech() = default;
+
+std::shared_ptr<HybridVadSpec> NitroOnnxSpeech::createVad() {
+  return std::make_shared<Vad>(threadPool_);
+}
+
+std::shared_ptr<HybridOfflineAsrSpec> NitroOnnxSpeech::createOfflineAsr() {
+  return std::make_shared<OfflineAsr>(threadPool_);
+}
+
+std::shared_ptr<HybridStreamingAsrSpec> NitroOnnxSpeech::createStreamingAsr() {
+  return std::make_shared<StreamingAsr>(threadPool_);
+}
+
+std::shared_ptr<HybridTtsSpec> NitroOnnxSpeech::createTts() {
+  return std::make_shared<Tts>(threadPool_);
+}
+
+std::shared_ptr<HybridSpeakerManagerSpec> NitroOnnxSpeech::createSpeakerManager() {
+  return std::make_shared<SpeakerManager>(threadPool_, cacheDir_);
+}
+
+std::string NitroOnnxSpeech::getVersion() {
+  return "0.1.0";
+}
+
+bool NitroOnnxSpeech::isQualcommCpu() {
+#ifdef __ANDROID__
+  FILE* f = fopen("/proc/cpuinfo", "r");
+  if (!f) return false;
+  char line[256];
+  bool found = false;
+  while (fgets(line, sizeof(line), f)) {
+    if (strstr(line, "Qualcomm") != nullptr) {
+      found = true;
+      break;
+    }
+  }
+  fclose(f);
+  return found;
+#else
+  return false;
+#endif
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/NitroOnnxSpeech.hpp

@@ -0,0 +1,42 @@
+// ------------------------------------------------------------------------------
+// OnnxSpeech.hpp
+// Factory for all Nitro hybrid objects in the module.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "ThreadPool.hpp"
+
+#include <NitroModules/HybridObject.hpp>
+#include <HybridOnnxSpeechSpec.hpp>
+#include <HybridOfflineAsrSpec.hpp>
+#include <HybridSpeakerManagerSpec.hpp>
+#include <HybridStreamingAsrSpec.hpp>
+#include <HybridTtsSpec.hpp>
+#include <HybridVadSpec.hpp>
+
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::onnx::speech {
+
+class NitroOnnxSpeech : public HybridOnnxSpeechSpec {
+ public:
+  static constexpr auto TAG = "NitroOnnxSpeech";
+
+  NitroOnnxSpeech();
+  ~NitroOnnxSpeech() override;
+
+  std::shared_ptr<HybridVadSpec> createVad() override;
+  std::shared_ptr<HybridOfflineAsrSpec> createOfflineAsr() override;
+  std::shared_ptr<HybridStreamingAsrSpec> createStreamingAsr() override;
+  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_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/OfflineAsr.cpp

@@ -0,0 +1,81 @@
+// ------------------------------------------------------------------------------
+// OfflineAsr.cpp
+// ------------------------------------------------------------------------------
+#include "OfflineAsr.hpp"
+
+#include "AudioUtils.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+AsrResult toAsrResult(const AsrEngineResult& native) {
+  std::vector<double> timestamps;
+  timestamps.reserve(native.timestamps.size());
+  for (float t : native.timestamps) {
+    timestamps.push_back(static_cast<double>(t));
+  }
+  return AsrResult(
+      native.text,
+      std::optional<double>(static_cast<double>(native.score)),
+      std::optional<double>(static_cast<double>(native.startMs)),
+      std::optional<double>(static_cast<double>(native.endMs)),
+      timestamps.empty() ? std::nullopt : std::optional<std::vector<double>>(timestamps),
+      native.json.empty() ? std::nullopt : std::optional<std::string>(native.json));
+}
+
+}  // namespace
+
+OfflineAsr::OfflineAsr(std::shared_ptr<ThreadPool> threadPool)
+    : HybridObject(TAG), engine_(std::move(threadPool)) {}
+
+OfflineAsr::~OfflineAsr() {
+  engine_.unload();
+}
+
+std::shared_ptr<Promise<void>> OfflineAsr::load(const AsrModelConfig& config) {
+  return Promise<void>::async([this, config]() {
+    AsrEngineConfig native;
+    native.type = config.type;
+    native.modelDir = config.modelDir;
+    native.tokensPath = config.tokensPath;
+    native.whisperEncoder = config.whisperEncoder.value_or("");
+    native.whisperDecoder = config.whisperDecoder.value_or("");
+    native.encoder = config.encoder.value_or("");
+    native.decoder = config.decoder.value_or("");
+    native.joiner = config.joiner.value_or("");
+    native.model = config.model.value_or("");
+    native.config = config.config.value_or("");
+    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.language = config.language.value_or("en");
+    native.useItn = config.useItn.value_or(true);
+    engine_.load(native);
+  });
+}
+
+bool OfflineAsr::isLoaded() {
+  return engine_.isLoaded();
+}
+
+std::shared_ptr<Promise<AsrResult>> OfflineAsr::recognize(
+    const std::shared_ptr<ArrayBuffer>& samples) {
+  return Promise<AsrResult>::async([this, samples]() {
+    auto floatSamples = bytesToFloatVector(samples->data(), samples->size());
+    return toAsrResult(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)); });
+}
+
+std::shared_ptr<Promise<void>> OfflineAsr::unload() {
+  return Promise<void>::async([this]() { engine_.unload(); });
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/OfflineAsr.hpp

@@ -0,0 +1,33 @@
+// ------------------------------------------------------------------------------
+// OfflineAsr.hpp
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "AsrEngine.hpp"
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/HybridObject.hpp>
+#include <HybridOfflineAsrSpec.hpp>
+
+#include <memory>
+
+namespace margelo::nitro::onnx::speech {
+
+class OfflineAsr : public HybridOfflineAsrSpec {
+ public:
+  static constexpr auto TAG = "OfflineAsr";
+
+  explicit OfflineAsr(std::shared_ptr<ThreadPool> threadPool);
+  ~OfflineAsr() override;
+
+  std::shared_ptr<Promise<void>> load(const AsrModelConfig& config) override;
+  bool isLoaded() override;
+  std::shared_ptr<Promise<AsrResult>> recognize(const std::shared_ptr<ArrayBuffer>& samples) override;
+  std::shared_ptr<Promise<AsrResult>> recognizeFile(const std::string& path) override;
+  std::shared_ptr<Promise<void>> unload() override;
+
+ private:
+  OfflineAsrEngine engine_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/ResourceDir.cpp

@@ -0,0 +1,29 @@
+// ------------------------------------------------------------------------------
+// ResourceDir.cpp
+// ------------------------------------------------------------------------------
+#include "ResourceDir.hpp"
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+std::string g_resourceDir;
+std::string g_cacheDir;
+}
+
+const std::string& getResourceDir() {
+  return g_resourceDir;
+}
+
+void setResourceDir(const std::string& dir) {
+  g_resourceDir = dir;
+}
+
+const std::string& getCacheDir() {
+  return g_cacheDir;
+}
+
+void setCacheDir(const std::string& dir) {
+  g_cacheDir = dir;
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/ResourceDir.hpp

@@ -0,0 +1,18 @@
+// ------------------------------------------------------------------------------
+// ResourceDir.hpp
+// Process-wide directories for bundled model files and persistent cache.
+// Set once from the platform layer at startup (JNI on Android, ObjC++ on iOS).
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include <string>
+
+namespace margelo::nitro::onnx::speech {
+
+const std::string& getResourceDir();
+void setResourceDir(const std::string& dir);
+
+const std::string& getCacheDir();
+void setCacheDir(const std::string& dir);
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/SpeakerEngine.cpp

@@ -0,0 +1,170 @@
+// ------------------------------------------------------------------------------
+// SpeakerEngine.cpp
+// ------------------------------------------------------------------------------
+#include "SpeakerEngine.hpp"
+
+#include "AudioFileReader.hpp"
+#include "sherpa-onnx/c-api/c-api.h"
+
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+std::string joinPath(const std::string& dir, const std::string& file) {
+  if (file.empty()) {
+    return dir;
+  }
+  if (file[0] == '/') {
+    return file;
+  }
+  if (dir.empty()) {
+    return file;
+  }
+  if (dir.back() == '/') {
+    return dir + file;
+  }
+  return dir + "/" + file;
+}
+
+ModelSingleton<const SherpaOnnxSpeakerEmbeddingExtractor> gExtractorCache;
+
+}  // namespace
+
+SpeakerEngine::SpeakerEngine(std::shared_ptr<ThreadPool> threadPool, std::string cacheDir)
+    : threadPool_(std::move(threadPool)), cacheDir_(std::move(cacheDir)) {}
+
+SpeakerEngine::~SpeakerEngine() {
+  unload();
+}
+
+void SpeakerEngine::load(const SpeakerEngineConfig& config) {
+  unload();
+  config_ = config;
+
+  const std::string key = config_.modelDir + "|speaker";
+  auto cached = gExtractorCache.getOrCreate(key, [this](const std::string&) {
+    SherpaOnnxSpeakerEmbeddingExtractorConfig c;
+    std::memset(&c, 0, sizeof(c));
+
+    std::string model = joinPath(config_.modelDir, config_.model);
+    c.model = model.c_str();
+    c.num_threads = config_.numThreads;
+    c.debug = 0;
+
+    const SherpaOnnxSpeakerEmbeddingExtractor* ex = SherpaOnnxCreateSpeakerEmbeddingExtractor(&c);
+    if (ex == nullptr) {
+      throw std::runtime_error("Failed to create speaker embedding extractor");
+    }
+    return std::shared_ptr<const SherpaOnnxSpeakerEmbeddingExtractor>(
+        ex, SherpaOnnxDestroySpeakerEmbeddingExtractor);
+  });
+
+  extractor_ = cached;
+}
+
+bool SpeakerEngine::isLoaded() const {
+  return extractor_ != nullptr;
+}
+
+std::vector<float> SpeakerEngine::computeEmbedding(const std::vector<float>& samples) {
+  if (extractor_ == nullptr) {
+    throw std::runtime_error("Speaker extractor not loaded");
+  }
+
+  const SherpaOnnxOnlineStream* stream = SherpaOnnxSpeakerEmbeddingExtractorCreateStream(extractor_.get());
+  SherpaOnnxOnlineStreamAcceptWaveform(stream, 16000, samples.data(), static_cast<int32_t>(samples.size()));
+  SherpaOnnxOnlineStreamInputFinished(stream);
+
+  const float* embedding = SherpaOnnxSpeakerEmbeddingExtractorComputeEmbedding(extractor_.get(), stream);
+  if (embedding == nullptr) {
+    SherpaOnnxDestroyOnlineStream(stream);
+    throw std::runtime_error("Failed to compute speaker embedding");
+  }
+
+  int32_t dim = SherpaOnnxSpeakerEmbeddingExtractorDim(extractor_.get());
+  std::vector<float> result(embedding, embedding + dim);
+  SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(embedding);
+  SherpaOnnxDestroyOnlineStream(stream);
+  return result;
+}
+
+SpeakerEngineRegisteredSpeaker SpeakerEngine::registerSpeaker(
+    const std::string& id,
+    const std::string& name,
+    const std::vector<float>& embedding) {
+  const std::string speakersDir = joinPath(cacheDir_, "speakers");
+  std::filesystem::create_directories(speakersDir);
+  const std::string path = joinPath(speakersDir, id + ".bin");
+  std::ofstream file(path, std::ios::binary);
+  if (!file) {
+    throw std::runtime_error("Failed to write speaker embedding: " + path);
+  }
+  const auto nameLen = static_cast<uint32_t>(name.size());
+  file.write(reinterpret_cast<const char*>(&nameLen), sizeof(nameLen));
+  file.write(name.data(), name.size());
+  file.write(reinterpret_cast<const char*>(embedding.data()), embedding.size() * sizeof(float));
+  return {id, name, path};
+}
+
+SpeakerEngineRegisteredSpeaker SpeakerEngine::registerSpeakerFromFile(
+    const std::string& id,
+    const std::string& name,
+    const std::string& path) {
+  if (extractor_ == nullptr) {
+    throw std::runtime_error("Speaker extractor not loaded");
+  }
+  std::vector<float> samples;
+  if (path.size() >= 4 && path.substr(path.size() - 4) == ".wav") {
+    samples = readWavFile(path);
+  } else {
+    samples = readRawPcmFile(path);
+  }
+  auto embedding = computeEmbedding(samples);
+  return registerSpeaker(id, name, embedding);
+}
+
+std::vector<SpeakerEngineRegisteredSpeaker> SpeakerEngine::listSpeakers() {
+  const std::string speakersDir = joinPath(cacheDir_, "speakers");
+  std::vector<SpeakerEngineRegisteredSpeaker> result;
+  if (!std::filesystem::exists(speakersDir)) {
+    return result;
+  }
+  for (const auto& entry : std::filesystem::directory_iterator(speakersDir)) {
+    if (!entry.is_regular_file()) continue;
+    const auto& filePath = entry.path();
+    if (filePath.extension() != ".bin") continue;
+    const std::string id = filePath.stem().string();
+    std::ifstream file(filePath, std::ios::binary);
+    if (!file) continue;
+    uint32_t nameLen = 0;
+    file.read(reinterpret_cast<char*>(&nameLen), sizeof(nameLen));
+    std::string name;
+    if (nameLen > 0 && nameLen < 1024) {
+      name.resize(nameLen);
+      file.read(name.data(), nameLen);
+    }
+    result.push_back({id, name, filePath.string()});
+  }
+  return result;
+}
+
+void SpeakerEngine::removeSpeaker(const std::string& id) {
+  const std::string path = joinPath(cacheDir_, "speakers/" + id + ".bin");
+  std::error_code ec;
+  std::filesystem::remove(path, ec);
+  if (ec) {
+    throw std::runtime_error("Failed to remove speaker: " + id + " (" + ec.message() + ")");
+  }
+}
+
+void SpeakerEngine::unload() {
+  extractor_.reset();
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/SpeakerEngine.hpp

@@ -0,0 +1,70 @@
+// ------------------------------------------------------------------------------
+// SpeakerEngine.hpp
+// Speaker embedding extraction and voice-cloning registration.
+// Supports two cloning paths:
+//   1. Reference-audio embedding passed directly to a TTS model.
+//   2. Explicit speaker registration via speaker embedding model, later
+//      referenced by speaker ID during TTS synthesis.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "AudioUtils.hpp"
+#include "ModelSingleton.hpp"
+#include "ThreadPool.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+struct SherpaOnnxSpeakerEmbeddingExtractor;
+struct SherpaOnnxSpeakerEmbeddingExtractorConfig;
+
+namespace margelo::nitro::onnx::speech {
+
+/** Native configuration for the speaker embedding extractor. */
+struct SpeakerEngineConfig {
+  std::string modelDir;
+  std::string model;
+  int32_t numThreads = 4;
+};
+
+/** Native registered speaker metadata before conversion to the generated type. */
+struct SpeakerEngineRegisteredSpeaker {
+  std::string id;
+  std::string name;
+  std::string embeddingPath;
+};
+
+/** Speaker manager engine. */
+class SpeakerEngine final {
+ public:
+  explicit SpeakerEngine(std::shared_ptr<ThreadPool> threadPool, std::string cacheDir);
+  ~SpeakerEngine();
+
+  SpeakerEngine(const SpeakerEngine&) = delete;
+  SpeakerEngine& operator=(const SpeakerEngine&) = delete;
+
+  void load(const SpeakerEngineConfig& config);
+  bool isLoaded() const;
+
+  /** Compute an embedding from 16 kHz mono f32 PCM audio. */
+  std::vector<float> computeEmbedding(const std::vector<float>& samples);
+
+  /** Register a speaker embedding for later TTS use. */
+  SpeakerEngineRegisteredSpeaker registerSpeaker(const std::string& id, const std::string& name, const std::vector<float>& embedding);
+
+  /** Register a speaker from a reference audio file. */
+  SpeakerEngineRegisteredSpeaker registerSpeakerFromFile(const std::string& id, const std::string& name, const std::string& path);
+
+  std::vector<SpeakerEngineRegisteredSpeaker> listSpeakers();
+  void removeSpeaker(const std::string& id);
+  void unload();
+
+ private:
+  std::shared_ptr<ThreadPool> threadPool_;
+  std::string cacheDir_;
+  SpeakerEngineConfig config_;
+  std::shared_ptr<const SherpaOnnxSpeakerEmbeddingExtractor> extractor_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/SpeakerManager.cpp

@@ -0,0 +1,93 @@
+// ------------------------------------------------------------------------------
+// SpeakerManager.cpp
+// ------------------------------------------------------------------------------
+#include "SpeakerManager.hpp"
+
+#include "AudioUtils.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+RegisteredSpeaker toRegisteredSpeaker(const SpeakerEngineRegisteredSpeaker& native) {
+  return RegisteredSpeaker(native.id, native.name, native.embeddingPath);
+}
+
+std::vector<RegisteredSpeaker> toRegisteredSpeakers(const std::vector<SpeakerEngineRegisteredSpeaker>& natives) {
+  std::vector<RegisteredSpeaker> result;
+  result.reserve(natives.size());
+  for (const auto& native : natives) {
+    result.push_back(toRegisteredSpeaker(native));
+  }
+  return result;
+}
+
+}  // namespace
+
+SpeakerManager::SpeakerManager(std::shared_ptr<ThreadPool> threadPool, std::string cacheDir)
+    : HybridObject(TAG), engine_(std::move(threadPool), std::move(cacheDir)) {}
+
+SpeakerManager::~SpeakerManager() {
+  engine_.unload();
+}
+
+std::shared_ptr<Promise<void>> SpeakerManager::load(const SpeakerEmbeddingConfig& config) {
+  return Promise<void>::async([this, config]() {
+    SpeakerEngineConfig native;
+    native.modelDir = config.modelDir;
+    native.model = config.model;
+    native.numThreads = config.numThreads;
+    engine_.load(native);
+  });
+}
+
+bool SpeakerManager::isLoaded() {
+  return engine_.isLoaded();
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> SpeakerManager::computeEmbedding(
+    const std::shared_ptr<ArrayBuffer>& samples) {
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, samples]() {
+    auto floatSamples = bytesToFloatVector(samples->data(), samples->size());
+    auto embedding = engine_.computeEmbedding(floatSamples);
+    auto bytes = floatVectorToBytes(embedding);
+    return ArrayBuffer::move(std::move(bytes));
+  });
+}
+
+std::shared_ptr<Promise<RegisteredSpeaker>> SpeakerManager::registerSpeaker(
+    const std::string& id,
+    const std::string& name,
+    const std::shared_ptr<ArrayBuffer>& embedding) {
+  return Promise<RegisteredSpeaker>::async([this, id, name, embedding]() {
+    auto floatEmbedding = bytesToFloatVector(embedding->data(), embedding->size());
+    return toRegisteredSpeaker(engine_.registerSpeaker(id, name, floatEmbedding));
+  });
+}
+
+std::shared_ptr<Promise<RegisteredSpeaker>> SpeakerManager::registerSpeakerFromFile(
+    const std::string& id,
+    const std::string& name,
+    const std::string& path) {
+  return Promise<RegisteredSpeaker>::async([this, id, name, path]() {
+    return toRegisteredSpeaker(engine_.registerSpeakerFromFile(id, name, path));
+  });
+}
+
+std::shared_ptr<Promise<std::vector<RegisteredSpeaker>>> SpeakerManager::listSpeakers() {
+  return Promise<std::vector<RegisteredSpeaker>>::async([this]() {
+    return toRegisteredSpeakers(engine_.listSpeakers());
+  });
+}
+
+std::shared_ptr<Promise<void>> SpeakerManager::removeSpeaker(const std::string& id) {
+  return Promise<void>::async([this, id]() { engine_.removeSpeaker(id); });
+}
+
+std::shared_ptr<Promise<void>> SpeakerManager::unload() {
+  return Promise<void>::async([this]() { engine_.unload(); });
+}
+
+}  // namespace margelo::nitro::onnx::speech