react-native-nitro-onnx 0.1.0

package/cpp/TtsEngine.cpp

@@ -0,0 +1,222 @@
+// ------------------------------------------------------------------------------
+// TtsEngine.cpp
+// ------------------------------------------------------------------------------
+#include "TtsEngine.hpp"
+
+#include "sherpa-onnx/c-api/c-api.h"
+
+#include <cstring>
+#include <stdexcept>
+#include <string>
+#include <cstdio>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#define TTS_LOG(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, "TtsEngine", fmt, ##__VA_ARGS__)
+#else
+#define TTS_LOG(fmt, ...) fprintf(stderr, "[TtsEngine] " fmt "\n", ##__VA_ARGS__)
+#endif
+
+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;
+}
+
+void checkFile(const std::string& path, const std::string& name) {
+  if (path.empty()) return;
+  FILE* f = fopen(path.c_str(), "rb");
+  if (!f) {
+    TTS_LOG("MISSING %s: %s", name.c_str(), path.c_str());
+    throw std::runtime_error("TTS model file not found: " + name + " -> " + path);
+  }
+  fclose(f);
+}
+
+ModelSingleton<const SherpaOnnxOfflineTts> gTtsCache;
+
+}  // namespace
+
+TtsEngine::TtsEngine(std::shared_ptr<ThreadPool> threadPool)
+    : threadPool_(std::move(threadPool)) {}
+
+TtsEngine::~TtsEngine() {
+  unload();
+}
+
+void TtsEngine::load(const TtsEngineConfig& config) {
+  unload();
+  config_ = config;
+
+  const std::string key = config_.modelDir + "|" + std::to_string(static_cast<int>(config_.type));
+  auto cached = gTtsCache.getOrCreate(key, [this](const std::string&) {
+    SherpaOnnxOfflineTtsConfig c;
+    std::memset(&c, 0, sizeof(c));
+
+    std::string model = joinPath(config_.modelDir, config_.model);
+    std::string acoustic = joinPath(config_.modelDir, config_.acousticModel);
+    std::string vocoder = joinPath(config_.modelDir, config_.vocoder);
+    std::string tokens = joinPath(config_.modelDir, config_.tokens);
+    std::string lexicon = joinPath(config_.modelDir, config_.lexicon);
+    std::string voices = joinPath(config_.modelDir, config_.voices);
+    std::string espeakNgData = joinPath(config_.modelDir, config_.espeakNgData);
+    std::string dictDir = joinPath(config_.modelDir, config_.dictDir);
+    std::string configPath = joinPath(config_.modelDir, config_.config);
+
+    std::string lmMain = joinPath(config_.modelDir, config_.lmMain);
+    std::string lmFlow = joinPath(config_.modelDir, config_.lmFlow);
+    std::string textConditioner = joinPath(config_.modelDir, config_.textConditioner);
+    std::string pocketEncoder = joinPath(config_.modelDir, config_.pocketEncoder);
+    std::string pocketDecoder = joinPath(config_.modelDir, config_.pocketDecoder);
+    std::string vocabJson = joinPath(config_.modelDir, config_.vocabJson);
+    std::string tokenScoresJson = joinPath(config_.modelDir, config_.tokenScoresJson);
+
+    std::string zipvoiceEncoder = joinPath(config_.modelDir, config_.zipvoiceEncoder);
+    std::string zipvoiceDecoder = joinPath(config_.modelDir, config_.zipvoiceDecoder);
+
+    switch (config_.type) {
+      case TtsModelType::KOKORO: {
+        const std::string& kokoroModel = config_.model.empty() ? acoustic : model;
+        TTS_LOG("Kokoro model:    %s", kokoroModel.c_str());
+        TTS_LOG("Kokoro voices:   %s", voices.c_str());
+        TTS_LOG("Kokoro tokens:   %s", tokens.c_str());
+        TTS_LOG("Kokoro data_dir: %s", espeakNgData.c_str());
+        TTS_LOG("Kokoro dict_dir: %s", dictDir.c_str());
+        TTS_LOG("Kokoro lexicon:  %s", lexicon.c_str());
+        checkFile(kokoroModel, "kokoro.model");
+        checkFile(voices, "kokoro.voices");
+        checkFile(tokens, "kokoro.tokens");
+        checkFile(lexicon, "kokoro.lexicon");
+        c.model.kokoro.model = kokoroModel.c_str();
+        c.model.kokoro.voices = voices.c_str();
+        c.model.kokoro.tokens = tokens.c_str();
+        c.model.kokoro.data_dir = espeakNgData.c_str();
+        c.model.kokoro.dict_dir = dictDir.c_str();
+        c.model.kokoro.lexicon = lexicon.c_str();
+        break;
+      }
+      case TtsModelType::VITS: {
+        const std::string& vitsModel = config_.model.empty() ? acoustic : model;
+        c.model.vits.model = vitsModel.c_str();
+        c.model.vits.lexicon = lexicon.c_str();
+        c.model.vits.tokens = tokens.c_str();
+        c.model.vits.data_dir = espeakNgData.c_str();
+        c.model.vits.dict_dir = dictDir.c_str();
+        break;
+      }
+      case TtsModelType::MATCHA:
+        c.model.matcha.acoustic_model = acoustic.c_str();
+        c.model.matcha.vocoder = vocoder.c_str();
+        c.model.matcha.lexicon = lexicon.c_str();
+        c.model.matcha.tokens = tokens.c_str();
+        c.model.matcha.data_dir = espeakNgData.c_str();
+        c.model.matcha.dict_dir = dictDir.c_str();
+        break;
+      case TtsModelType::POCKET:
+        c.model.pocket.lm_main = lmMain.c_str();
+        c.model.pocket.lm_flow = lmFlow.c_str();
+        c.model.pocket.encoder = pocketEncoder.c_str();
+        c.model.pocket.decoder = pocketDecoder.c_str();
+        c.model.pocket.text_conditioner = textConditioner.c_str();
+        c.model.pocket.vocab_json = vocabJson.c_str();
+        c.model.pocket.token_scores_json = tokenScoresJson.c_str();
+        break;
+      case TtsModelType::ZIPVOICE:
+        c.model.zipvoice.tokens = tokens.c_str();
+        c.model.zipvoice.encoder = zipvoiceEncoder.c_str();
+        c.model.zipvoice.decoder = zipvoiceDecoder.c_str();
+        c.model.zipvoice.vocoder = vocoder.c_str();
+        c.model.zipvoice.data_dir = espeakNgData.c_str();
+        c.model.zipvoice.lexicon = lexicon.c_str();
+        break;
+    }
+
+    c.model.num_threads = config_.numThreads;
+    c.model.debug = 1;
+    c.model.provider = "cpu";
+    c.rule_fsts = "";
+    c.rule_fars = "";
+    c.max_num_sentences = 1;
+
+    const SherpaOnnxOfflineTts* tts = SherpaOnnxCreateOfflineTts(&c);
+    if (tts == nullptr) {
+      TTS_LOG("SherpaOnnxCreateOfflineTts returned nullptr (type=%d, modelDir=%s)",
+              static_cast<int>(config_.type), config_.modelDir.c_str());
+      throw std::runtime_error(
+          "Failed to create TTS engine (type=" +
+          std::to_string(static_cast<int>(config_.type)) +
+          ", modelDir=" + config_.modelDir + ")");
+    }
+    return std::shared_ptr<const SherpaOnnxOfflineTts>(tts, SherpaOnnxDestroyOfflineTts);
+  });
+
+  tts_ = cached;
+}
+
+bool TtsEngine::isLoaded() const {
+  return tts_ != nullptr;
+}
+
+TtsEngineResult TtsEngine::synthesize(const std::string& text, int32_t speakerId, float speed) {
+  if (tts_ == nullptr) {
+    throw std::runtime_error("TTS not loaded");
+  }
+
+  const int32_t sid = speakerId >= 0 ? speakerId : config_.speakerId;
+  const float playbackSpeed = speed > 0.0f ? speed : config_.speed;
+
+  SherpaOnnxGenerationConfig genConfig;
+  std::memset(&genConfig, 0, sizeof(genConfig));
+  genConfig.sid = sid;
+  genConfig.speed = playbackSpeed;
+
+  const SherpaOnnxGeneratedAudio* audio = SherpaOnnxOfflineTtsGenerateWithConfig(
+      tts_.get(), text.c_str(), &genConfig, nullptr, nullptr);
+  if (audio == nullptr) {
+    throw std::runtime_error("TTS synthesis failed");
+  }
+
+  TtsEngineResult result;
+  result.sampleRate = audio->sample_rate;
+  result.samples.assign(audio->samples, audio->samples + audio->n);
+
+  if (config_.outputSampleRate > 0 && config_.outputSampleRate != audio->sample_rate) {
+    const SherpaOnnxLinearResampler* resampler = SherpaOnnxCreateLinearResampler(
+        audio->sample_rate, config_.outputSampleRate, 0.0f, 0);
+    if (resampler != nullptr) {
+      const SherpaOnnxResampleOut* resampled = SherpaOnnxLinearResamplerResample(
+          resampler, result.samples.data(), static_cast<int32_t>(result.samples.size()), 1);
+      if (resampled != nullptr) {
+        result.samples.assign(resampled->samples, resampled->samples + resampled->n);
+        result.sampleRate = config_.outputSampleRate;
+        SherpaOnnxLinearResamplerResampleFree(resampled);
+      }
+      SherpaOnnxDestroyLinearResampler(resampler);
+    }
+  }
+
+  result.durationMs = static_cast<double>(result.samples.size()) * 1000.0 / result.sampleRate;
+
+  SherpaOnnxDestroyOfflineTtsGeneratedAudio(audio);
+  return result;
+}
+
+void TtsEngine::unload() {
+  tts_.reset();
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/TtsEngine.hpp

@@ -0,0 +1,77 @@
+// ------------------------------------------------------------------------------
+// TtsEngine.hpp
+// Text-to-speech wrapper backed by sherpa-onnx OfflineTts.
+// Supports Kokoro, VITS, Matcha, Pocket and ZipVoice (placeholder) models.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "AudioUtils.hpp"
+#include "ModelSingleton.hpp"
+#include "ThreadPool.hpp"
+
+#include "TtsModelType.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+struct SherpaOnnxOfflineTts;
+
+namespace margelo::nitro::onnx::speech {
+
+/** Unified native configuration for any supported TTS model. */
+struct TtsEngineConfig {
+  TtsModelType type = TtsModelType::KOKORO;
+  std::string modelDir;
+  std::string model;
+  std::string acousticModel;
+  std::string vocoder;
+  std::string tokens;
+  std::string lexicon;
+  std::string voices;
+  std::string espeakNgData;
+  std::string dictDir;
+  std::string lmMain;
+  std::string lmFlow;
+  std::string textConditioner;
+  std::string pocketEncoder;
+  std::string pocketDecoder;
+  std::string vocabJson;
+  std::string tokenScoresJson;
+  std::string zipvoiceEncoder;
+  std::string zipvoiceDecoder;
+  std::string config;
+  int32_t numThreads = 2;
+  int32_t outputSampleRate = 16000;
+  int32_t speakerId = 0;
+  float speed = 1.0f;
+};
+
+/** Native synthesis result (samples are kept as a float vector). */
+struct TtsEngineResult {
+  std::vector<float> samples;
+  int32_t sampleRate = 16000;
+  double durationMs = 0.0;
+};
+
+/** Text-to-speech engine. */
+class TtsEngine final {
+ public:
+  explicit TtsEngine(std::shared_ptr<ThreadPool> threadPool);
+  ~TtsEngine();
+
+  TtsEngine(const TtsEngine&) = delete;
+  TtsEngine& operator=(const TtsEngine&) = delete;
+
+  void load(const TtsEngineConfig& config);
+  bool isLoaded() const;
+  TtsEngineResult synthesize(const std::string& text, int32_t speakerId, float speed);
+  void unload();
+
+ private:
+  std::shared_ptr<ThreadPool> threadPool_;
+  TtsEngineConfig config_;
+  std::shared_ptr<const SherpaOnnxOfflineTts> tts_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/Vad.cpp

@@ -0,0 +1,126 @@
+// ------------------------------------------------------------------------------
+// Vad.cpp
+// ------------------------------------------------------------------------------
+#include "Vad.hpp"
+
+#include "AudioUtils.hpp"
+#include "ResourceDir.hpp"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+VadSegment toVadSegment(const VadEngineSegment& native) {
+  std::vector<uint8_t> bytes = floatVectorToBytes(native.samples);
+  return VadSegment(
+      static_cast<double>(native.startMs),
+      static_cast<double>(native.endMs),
+      ArrayBuffer::move(std::move(bytes)));
+}
+
+std::vector<VadSegment> toVadSegments(const std::vector<VadEngineSegment>& natives) {
+  std::vector<VadSegment> result;
+  result.reserve(natives.size());
+  for (const auto& native : natives) {
+    result.push_back(toVadSegment(native));
+  }
+  return result;
+}
+
+}  // namespace
+
+Vad::Vad(std::shared_ptr<ThreadPool> threadPool)
+    : HybridObject(TAG), engine_(std::move(threadPool)) {}
+
+Vad::~Vad() {
+  engine_.dispose();
+}
+
+std::shared_ptr<Promise<void>> Vad::initialize(const VadConfig& config) {
+  currentConfig_ = config;
+  return Promise<void>::async([this, config]() {
+    // Use the bundled silero_vad.onnx when no custom path is provided.
+    const std::string& resDir = getResourceDir();
+    const std::string modelPath = config.modelPath.value_or(
+        resDir.empty() ? "silero_vad.onnx" : resDir + "/silero_vad.onnx");
+    engine_.initialize(
+        {
+            .modelPath = modelPath,
+            .threshold = static_cast<float>(config.threshold.value_or(0.5)),
+            .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)),
+        },
+        shared_cast<Vad>());
+  });
+}
+
+bool Vad::isInitialized() {
+  return engine_.isInitialized();
+}
+
+std::shared_ptr<Promise<void>> Vad::process(const std::shared_ptr<ArrayBuffer>& samples) {
+  return Promise<void>::async([this, samples]() {
+    const auto data = samples->data();
+    auto floatSamples = bytesToFloatVector(data, samples->size());
+    engine_.acceptWaveform(floatSamples);
+  });
+}
+
+std::shared_ptr<Promise<std::vector<VadSegment>>> Vad::pullSegments() {
+  return Promise<std::vector<VadSegment>>::async([this]() { return toVadSegments(engine_.pullSegments()); });
+}
+
+std::shared_ptr<Promise<void>> Vad::reset() {
+  return Promise<void>::async([this]() { engine_.reset(); });
+}
+
+std::optional<std::function<void(const VadSegment& /* segment */)>> Vad::getOnSpeechStart() {
+  return onSpeechStart_;
+}
+
+void Vad::setOnSpeechStart(
+    const std::optional<std::function<void(const VadSegment& /* segment */)>>& onSpeechStart) {
+  onSpeechStart_ = onSpeechStart;
+}
+
+std::optional<std::function<void(const VadSegment& /* segment */)>> Vad::getOnSpeechEnd() {
+  return onSpeechEnd_;
+}
+
+void Vad::setOnSpeechEnd(
+    const std::optional<std::function<void(const VadSegment& /* segment */)>>& onSpeechEnd) {
+  onSpeechEnd_ = onSpeechEnd;
+}
+
+std::optional<std::function<void(const std::string& /* error */)>> Vad::getOnError() {
+  return onError_;
+}
+
+void Vad::setOnError(
+    const std::optional<std::function<void(const std::string& /* error */)>>& onError) {
+  onError_ = onError;
+}
+
+void Vad::onSpeechStart(const VadEngineSegment& segment) {
+  if (onSpeechStart_.has_value()) {
+    onSpeechStart_.value()(toVadSegment(segment));
+  }
+}
+
+void Vad::onSpeechEnd(const VadEngineSegment& segment) {
+  if (onSpeechEnd_.has_value()) {
+    onSpeechEnd_.value()(toVadSegment(segment));
+  }
+}
+
+void Vad::onError(const std::string& error) {
+  if (onError_.has_value()) {
+    onError_.value()(error);
+  }
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/Vad.hpp

@@ -0,0 +1,62 @@
+// ------------------------------------------------------------------------------
+// Vad.hpp
+// Nitro HybridObject implementation for the Vad spec.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "VadEngine.hpp"
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/HybridObject.hpp>
+#include <HybridVadSpec.hpp>
+
+#include <functional>
+#include <memory>
+#include <optional>
+
+namespace margelo::nitro::onnx::speech {
+
+/**
+ * Bridge between the Nitro Vad spec and the native VadEngine.
+ * Events are forwarded to JS through the generated event handler.
+ */
+class Vad : public HybridVadSpec,
+                public VadListener {
+ public:
+  static constexpr auto TAG = "Vad";
+
+  explicit Vad(std::shared_ptr<ThreadPool> threadPool);
+  ~Vad() override;
+
+  std::shared_ptr<Promise<void>> initialize(const VadConfig& config) override;
+  bool isInitialized() override;
+  std::shared_ptr<Promise<void>> process(const std::shared_ptr<ArrayBuffer>& samples) override;
+  std::shared_ptr<Promise<std::vector<VadSegment>>> pullSegments() override;
+  std::shared_ptr<Promise<void>> reset() override;
+
+  // Nitro event callback getters/setters.
+  std::optional<std::function<void(const VadSegment& /* segment */)>> getOnSpeechStart() override;
+  void setOnSpeechStart(
+      const std::optional<std::function<void(const VadSegment& /* segment */)>>& onSpeechStart) override;
+  std::optional<std::function<void(const VadSegment& /* segment */)>> getOnSpeechEnd() override;
+  void setOnSpeechEnd(
+      const std::optional<std::function<void(const VadSegment& /* segment */)>>& onSpeechEnd) override;
+  std::optional<std::function<void(const std::string& /* error */)>> getOnError() override;
+  void setOnError(
+      const std::optional<std::function<void(const std::string& /* error */)>>& onError) override;
+
+  // VadListener callbacks run on the background processor thread and forward
+  // into JS via the stored Nitro callbacks.
+  void onSpeechStart(const VadEngineSegment& segment) override;
+  void onSpeechEnd(const VadEngineSegment& segment) override;
+  void onError(const std::string& error) override;
+
+ private:
+  VadEngine engine_;
+  VadConfig currentConfig_;
+  std::optional<std::function<void(const VadSegment&)>> onSpeechStart_;
+  std::optional<std::function<void(const VadSegment&)>> onSpeechEnd_;
+  std::optional<std::function<void(const std::string&)>> onError_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/VadEngine.cpp

@@ -0,0 +1,217 @@
+// ------------------------------------------------------------------------------
+// VadEngine.cpp
+// ------------------------------------------------------------------------------
+#include "VadEngine.hpp"
+
+#include "sherpa-onnx/c-api/c-api.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdexcept>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+constexpr int32_t kSampleRate = 16000;
+
+}  // namespace
+
+VadEngine::VadEngine(std::shared_ptr<ThreadPool> threadPool)
+    : threadPool_(std::move(threadPool)) {}
+
+VadEngine::~VadEngine() {
+  dispose();
+}
+
+void VadEngine::initialize(const VadEngineConfig& config, std::shared_ptr<VadListener> listener) {
+  dispose();
+
+  config_ = config;
+  listener_ = std::move(listener);
+  preBufferCapacity_ = static_cast<size_t>(msToSamples(config_.preBufferMs));
+  preBuffer_.reserve(preBufferCapacity_);
+  streamMs_ = 0.0f;
+  inSpeech_ = false;
+
+  SherpaOnnxVadModelConfig vadConfig;
+  std::memset(&vadConfig, 0, sizeof(vadConfig));
+  vadConfig.silero_vad.model = config_.modelPath.c_str();
+  vadConfig.silero_vad.threshold = config_.threshold;
+  vadConfig.silero_vad.min_silence_duration = config_.minSilenceDuration;
+  vadConfig.silero_vad.min_speech_duration = config_.minSpeechDuration;
+  vadConfig.sample_rate = kSampleRate;
+  vadConfig.num_threads = 1;
+
+  // The second argument is the buffer size in milliseconds used internally by
+  // sherpa-onnx. We reuse the configured pre-buffer duration.
+  vad_ = SherpaOnnxCreateVoiceActivityDetector(&vadConfig, config_.preBufferMs);
+  if (vad_ == nullptr) {
+    throw std::runtime_error("Failed to create sherpa-onnx VAD");
+  }
+
+  initialized_ = true;
+  stop_ = false;
+  processorThread_ = std::thread(&VadEngine::processLoop, this);
+}
+
+bool VadEngine::isInitialized() const {
+  return initialized_.load();
+}
+
+void VadEngine::acceptWaveform(const std::vector<float>& samples) {
+  {
+    std::lock_guard<std::mutex> lock(inputMutex_);
+    inputQueue_.emplace(samples);
+  }
+  inputCv_.notify_one();
+}
+
+std::vector<VadEngineSegment> VadEngine::pullSegments() {
+  std::lock_guard<std::mutex> lock(outputMutex_);
+  std::vector<VadEngineSegment> result = std::move(pendingSegments_);
+  pendingSegments_.clear();
+  return result;
+}
+
+void VadEngine::reset() {
+  {
+    std::lock_guard<std::mutex> lock(inputMutex_);
+    std::queue<std::vector<float>> empty;
+    inputQueue_.swap(empty);
+  }
+  {
+    std::lock_guard<std::mutex> lock(preBufferMutex_);
+    preBuffer_.clear();
+  }
+  {
+    std::lock_guard<std::mutex> lock(outputMutex_);
+    pendingSegments_.clear();
+  }
+
+  if (vad_) {
+    SherpaOnnxVoiceActivityDetectorClear(vad_);
+  }
+
+  // Defer speech-state clearing to the processor thread to avoid a data race.
+  resetRequested_ = true;
+}
+
+void VadEngine::dispose() {
+  stop_ = true;
+  inputCv_.notify_all();
+  if (processorThread_.joinable()) {
+    processorThread_.join();
+  }
+  if (vad_) {
+    SherpaOnnxDestroyVoiceActivityDetector(vad_);
+    vad_ = nullptr;
+  }
+  initialized_ = false;
+  listener_.reset();
+}
+
+void VadEngine::processLoop() {
+  while (!stop_) {
+    std::vector<float> chunk;
+    {
+      std::unique_lock<std::mutex> lock(inputMutex_);
+      inputCv_.wait(lock, [this]() { return stop_ || !inputQueue_.empty(); });
+      if (stop_) {
+        break;
+      }
+      chunk = std::move(inputQueue_.front());
+      inputQueue_.pop();
+    }
+
+    if (chunk.empty()) {
+      continue;
+    }
+
+    if (resetRequested_.exchange(false)) {
+      inSpeech_ = false;
+      currentSpeechSamples_.clear();
+      streamMs_ = 0.0f;
+    }
+
+    // Update the sliding pre-buffer with the newest chunk. This is the key
+    // mechanism that preserves leading audio for onSpeechStart/onSpeechEnd.
+    {
+      std::lock_guard<std::mutex> lock(preBufferMutex_);
+      preBuffer_.insert(preBuffer_.end(), chunk.begin(), chunk.end());
+      if (preBuffer_.size() > preBufferCapacity_) {
+        const size_t excess = preBuffer_.size() - preBufferCapacity_;
+        preBuffer_.erase(preBuffer_.begin(), preBuffer_.begin() + excess);
+      }
+    }
+
+    // Feed audio to sherpa-onnx on the background thread.
+    SherpaOnnxVoiceActivityDetectorAcceptWaveform(vad_, chunk.data(), static_cast<int32_t>(chunk.size()));
+    streamMs_ += samplesToMs(static_cast<int32_t>(chunk.size()));
+
+    const bool speechDetected = SherpaOnnxVoiceActivityDetectorDetected(vad_) != 0;
+
+    if (speechDetected && !inSpeech_) {
+      // Transition to speech: capture the sliding pre-buffer as the start of
+      // the segment and notify JS immediately so the UI can react without
+      // waiting for speech end.
+      inSpeech_ = true;
+      currentSpeechStartMs_ = streamMs_ - samplesToMs(static_cast<int32_t>(chunk.size()));
+      {
+        std::lock_guard<std::mutex> lock(preBufferMutex_);
+        currentSpeechSamples_ = preBuffer_;
+      }
+
+      VadEngineSegment startSegment;
+      startSegment.startMs = currentSpeechStartMs_ - samplesToMs(static_cast<int32_t>(currentSpeechSamples_.size()));
+      startSegment.endMs = currentSpeechStartMs_;
+      startSegment.samples = currentSpeechSamples_;
+      if (listener_) {
+        listener_->onSpeechStart(startSegment);
+      }
+    }
+
+    else if (inSpeech_) {
+      // Accumulate subsequent chunks into the active speech buffer.
+      // (On the iteration where speech is first detected, the pre-buffer
+      // already contains the triggering chunk, so we skip it here.)
+      currentSpeechSamples_.insert(currentSpeechSamples_.end(), chunk.begin(), chunk.end());
+    }
+
+    // Drain completed segments from sherpa-onnx. The segment returned by Front
+    // does not include our pre-buffer, so we emit the accumulated buffer
+    // instead. Timing is taken from our stream clock for consistency.
+    while (!SherpaOnnxVoiceActivityDetectorEmpty(vad_)) {
+      const SherpaOnnxSpeechSegment* seg = SherpaOnnxVoiceActivityDetectorFront(vad_);
+      if (seg == nullptr) {
+        break;
+      }
+
+      VadEngineSegment endSegment;
+      endSegment.startMs = currentSpeechStartMs_;
+      endSegment.endMs = streamMs_;
+      endSegment.samples = std::move(currentSpeechSamples_);
+
+      SherpaOnnxDestroySpeechSegment(seg);
+      SherpaOnnxVoiceActivityDetectorPop(vad_);
+
+      {
+        std::lock_guard<std::mutex> lock(outputMutex_);
+        pendingSegments_.push_back(endSegment);
+      }
+      if (listener_) {
+        listener_->onSpeechEnd(endSegment);
+      }
+
+      inSpeech_ = false;
+    }
+  }
+}
+
+void VadEngine::flushPreBuffer(std::vector<float>& target) {
+  std::lock_guard<std::mutex> lock(preBufferMutex_);
+  target.insert(target.end(), preBuffer_.begin(), preBuffer_.end());
+  preBuffer_.clear();
+}
+
+}  // namespace margelo::nitro::onnx::speech