react-native-nitro-onnx 0.1.0

package/cpp/AndroidPthreadCompat.cpp

@@ -0,0 +1,16 @@
+// ------------------------------------------------------------------------------
+// AndroidPthreadCompat.cpp
+// Android Bionic omits pthread_cancel(). sherpa-onnx's prebuilt .so references
+// it, so we provide a no-op stub that returns ESRCH (no such thread).
+// ------------------------------------------------------------------------------
+
+#ifdef __ANDROID__
+
+#include <cerrno>
+#include <pthread.h>
+
+extern "C" int pthread_cancel(pthread_t) {
+  return ESRCH;
+}
+
+#endif

package/cpp/AsrEngine.cpp

@@ -0,0 +1,277 @@
+// ------------------------------------------------------------------------------
+// AsrEngine.cpp
+// ------------------------------------------------------------------------------
+#include "AsrEngine.hpp"
+
+#include "AudioFileReader.hpp"
+#include "sherpa-onnx/c-api/c-api.h"
+
+#include <cstring>
+#include <fstream>
+#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 SherpaOnnxOfflineRecognizer> gOfflineRecognizerCache;
+ModelSingleton<const SherpaOnnxOnlineRecognizer> gOnlineRecognizerCache;
+
+}  // namespace
+
+// ------------------------------------------------------------------------------
+// Offline ASR
+// ------------------------------------------------------------------------------
+
+OfflineAsrEngine::OfflineAsrEngine(std::shared_ptr<ThreadPool> threadPool)
+    : threadPool_(std::move(threadPool)) {}
+
+OfflineAsrEngine::~OfflineAsrEngine() {
+  unload();
+}
+
+void OfflineAsrEngine::load(const AsrEngineConfig& config) {
+  unload();
+  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&) {
+    SherpaOnnxOfflineRecognizerConfig c;
+    std::memset(&c, 0, sizeof(c));
+
+    // All joined paths must outlive the call to CreateOfflineRecognizer.
+    std::string tokens = joinPath(config_.modelDir, config_.tokensPath);
+    std::string whisperEncoder = joinPath(config_.modelDir, config_.whisperEncoder);
+    std::string whisperDecoder = joinPath(config_.modelDir, config_.whisperDecoder);
+    std::string encoder = joinPath(config_.modelDir, config_.encoder);
+    std::string decoder = joinPath(config_.modelDir, config_.decoder);
+    std::string joiner = joinPath(config_.modelDir, config_.joiner);
+    std::string model = joinPath(config_.modelDir, config_.model);
+
+    switch (config_.type) {
+      case AsrModelType::WHISPER:
+        c.model_config.whisper.encoder = whisperEncoder.c_str();
+        c.model_config.whisper.decoder = whisperDecoder.c_str();
+        c.model_config.whisper.language = config_.language.c_str();
+        c.model_config.whisper.tail_paddings = 2;
+        break;
+      case AsrModelType::TRANSDUCER:
+      case AsrModelType::ZIPFORMER:
+      case AsrModelType::CONFORMER:
+        c.model_config.transducer.encoder = encoder.c_str();
+        c.model_config.transducer.decoder = decoder.c_str();
+        c.model_config.transducer.joiner = joiner.c_str();
+        break;
+      case AsrModelType::PARAFORMER:
+      case AsrModelType::WENET:
+      case AsrModelType::TELESPEECH:
+      case AsrModelType::SENSE_VOICE:
+        c.model_config.paraformer.model = model.c_str();
+        break;
+      case AsrModelType::MOONSHINE:
+      case AsrModelType::DOLPHIN:
+      case AsrModelType::NEMO:
+        c.model_config.nemo_ctc.model = model.c_str();
+        if (config_.type == AsrModelType::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.decoding_method = config_.decodingMethod.c_str();
+    c.max_active_paths = config_.maxActivePaths;
+
+    const SherpaOnnxOfflineRecognizer* rec = SherpaOnnxCreateOfflineRecognizer(&c);
+    if (rec == nullptr) {
+      throw std::runtime_error("Failed to create offline ASR recognizer");
+    }
+    return std::shared_ptr<const SherpaOnnxOfflineRecognizer>(
+        rec, SherpaOnnxDestroyOfflineRecognizer);
+  });
+
+  recognizer_ = cached;
+}
+
+bool OfflineAsrEngine::isLoaded() const {
+  return recognizer_ != nullptr;
+}
+
+AsrEngineResult OfflineAsrEngine::recognize(const std::vector<float>& samples) {
+  if (recognizer_ == nullptr) {
+    throw std::runtime_error("Offline ASR not loaded");
+  }
+
+  const SherpaOnnxOfflineStream* stream = SherpaOnnxCreateOfflineStream(recognizer_.get());
+  SherpaOnnxAcceptWaveformOffline(stream, 16000, samples.data(), static_cast<int32_t>(samples.size()));
+  SherpaOnnxDecodeOfflineStream(recognizer_.get(), stream);
+
+  const char* json = SherpaOnnxGetOfflineStreamResultAsJson(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);
+    }
+  }
+  result.endMs = samplesToMs(static_cast<int32_t>(samples.size()));
+
+  SherpaOnnxDestroyOfflineStream(stream);
+  return result;
+}
+
+AsrEngineResult OfflineAsrEngine::recognizeFile(const std::string& path) {
+  std::vector<float> samples;
+  if (path.size() >= 4 && path.substr(path.size() - 4) == ".wav") {
+    samples = readWavFile(path);
+  } else {
+    samples = readRawPcmFile(path);
+  }
+  return recognize(samples);
+}
+
+void OfflineAsrEngine::unload() {
+  recognizer_.reset();
+}
+
+// ------------------------------------------------------------------------------
+// Streaming ASR
+// ------------------------------------------------------------------------------
+
+StreamingAsrEngine::StreamingAsrEngine(std::shared_ptr<ThreadPool> threadPool)
+    : threadPool_(std::move(threadPool)) {}
+
+StreamingAsrEngine::~StreamingAsrEngine() {
+  unload();
+}
+
+void StreamingAsrEngine::load(
+    const AsrEngineConfig& config,
+    std::shared_ptr<StreamingAsrListener> listener) {
+  unload();
+  config_ = config;
+  listener_ = std::move(listener);
+
+  const std::string key = config_.modelDir + "|streaming|" + std::to_string(static_cast<int>(config_.type));
+  auto cached = gOnlineRecognizerCache.getOrCreate(key, [this](const std::string&) {
+    SherpaOnnxOnlineRecognizerConfig c;
+    std::memset(&c, 0, sizeof(c));
+
+    std::string tokens = joinPath(config_.modelDir, config_.tokensPath);
+    std::string encoder = joinPath(config_.modelDir, config_.encoder);
+    std::string decoder = joinPath(config_.modelDir, config_.decoder);
+    std::string joiner = joinPath(config_.modelDir, config_.joiner);
+
+    switch (config_.type) {
+      case AsrModelType::TRANSDUCER:
+      case AsrModelType::ZIPFORMER:
+      case AsrModelType::CONFORMER:
+        c.model_config.transducer.encoder = encoder.c_str();
+        c.model_config.transducer.decoder = decoder.c_str();
+        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");
+    }
+
+    c.model_config.tokens = tokens.c_str();
+    c.model_config.num_threads = config_.numThreads;
+    c.decoding_method = config_.decodingMethod.c_str();
+    c.max_active_paths = config_.maxActivePaths;
+    c.enable_endpoint = 1;
+
+    const SherpaOnnxOnlineRecognizer* rec = SherpaOnnxCreateOnlineRecognizer(&c);
+    if (rec == nullptr) {
+      throw std::runtime_error("Failed to create streaming ASR recognizer");
+    }
+    return std::shared_ptr<const SherpaOnnxOnlineRecognizer>(rec, SherpaOnnxDestroyOnlineRecognizer);
+  });
+
+  recognizer_ = cached;
+  stream_ = std::shared_ptr<const SherpaOnnxOnlineStream>(
+      SherpaOnnxCreateOnlineStream(recognizer_.get()),
+      SherpaOnnxDestroyOnlineStream);
+}
+
+bool StreamingAsrEngine::isLoaded() const {
+  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);
+    }
+  }
+}
+
+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());
+  AsrEngineResult result;
+  if (json != nullptr) {
+    result.json = json;
+    // TODO: parse text from JSON.
+    SherpaOnnxDestroyOnlineStreamResultJson(json);
+  }
+  if (listener_) {
+    listener_->onFinalResult(result);
+  }
+  return result;
+}
+
+void StreamingAsrEngine::reset() {
+  if (recognizer_ != nullptr) {
+    stream_ = std::shared_ptr<const SherpaOnnxOnlineStream>(
+        SherpaOnnxCreateOnlineStream(recognizer_.get()),
+        SherpaOnnxDestroyOnlineStream);
+  }
+}
+
+void StreamingAsrEngine::unload() {
+  stream_.reset();
+  recognizer_.reset();
+  listener_.reset();
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/AsrEngine.hpp

@@ -0,0 +1,110 @@
+// ------------------------------------------------------------------------------
+// AsrEngine.hpp
+// Offline and streaming ASR wrappers backed by sherpa-onnx.
+// Supports Whisper, Transducer, Paraformer, Zipformer, Conformer, Wenet,
+// Telespeech, Moonshine, Dolphin, NeMo and SenseVoice through a unified
+// AsrModelConfig structure.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include "AudioUtils.hpp"
+#include "ModelSingleton.hpp"
+#include "ThreadPool.hpp"
+
+#include "AsrModelType.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+struct SherpaOnnxOfflineRecognizer;
+struct SherpaOnnxOnlineRecognizer;
+struct SherpaOnnxOfflineStream;
+struct SherpaOnnxOnlineStream;
+
+namespace margelo::nitro::onnx::speech {
+
+/** Unified native configuration for any supported ASR model. */
+struct AsrEngineConfig {
+  AsrModelType type = AsrModelType::WHISPER;
+  std::string modelDir;
+  std::string tokensPath;
+  std::string whisperEncoder;
+  std::string whisperDecoder;
+  std::string encoder;
+  std::string decoder;
+  std::string joiner;
+  std::string model;
+  std::string config;
+  int32_t numThreads = 4;
+  std::string decodingMethod = "greedy_search";
+  int32_t maxActivePaths = 4;
+  std::string language = "en";
+  bool useItn = true;
+};
+
+/** Native recognition result before conversion to the generated AsrResult. */
+struct AsrEngineResult {
+  std::string text;
+  float score = 0.0f;
+  float startMs = 0.0f;
+  float endMs = 0.0f;
+  std::vector<float> timestamps;
+  std::string json;
+};
+
+/** Streaming ASR event listener. */
+class StreamingAsrListener {
+ public:
+  virtual ~StreamingAsrListener() = default;
+  virtual void onPartialResult(const AsrEngineResult& result) = 0;
+  virtual void onFinalResult(const AsrEngineResult& result) = 0;
+  virtual void onError(const std::string& error) = 0;
+};
+
+/** Offline ASR engine. */
+class OfflineAsrEngine final {
+ public:
+  explicit OfflineAsrEngine(std::shared_ptr<ThreadPool> threadPool);
+  ~OfflineAsrEngine();
+
+  OfflineAsrEngine(const OfflineAsrEngine&) = delete;
+  OfflineAsrEngine& operator=(const OfflineAsrEngine&) = delete;
+
+  void load(const AsrEngineConfig& config);
+  bool isLoaded() const;
+  AsrEngineResult recognize(const std::vector<float>& samples);
+  AsrEngineResult recognizeFile(const std::string& path);
+  void unload();
+
+ private:
+  std::shared_ptr<ThreadPool> threadPool_;
+  AsrEngineConfig config_;
+  std::shared_ptr<const SherpaOnnxOfflineRecognizer> recognizer_;
+};
+
+/** Streaming ASR engine. */
+class StreamingAsrEngine final {
+ public:
+  explicit StreamingAsrEngine(std::shared_ptr<ThreadPool> threadPool);
+  ~StreamingAsrEngine();
+
+  StreamingAsrEngine(const StreamingAsrEngine&) = delete;
+  StreamingAsrEngine& operator=(const StreamingAsrEngine&) = delete;
+
+  void load(const AsrEngineConfig& config, std::shared_ptr<StreamingAsrListener> listener);
+  bool isLoaded() const;
+  void acceptWaveform(const std::vector<float>& samples);
+  AsrEngineResult finalize();
+  void reset();
+  void unload();
+
+ private:
+  std::shared_ptr<ThreadPool> threadPool_;
+  AsrEngineConfig config_;
+  std::shared_ptr<StreamingAsrListener> listener_;
+  std::shared_ptr<const SherpaOnnxOnlineRecognizer> recognizer_;
+  std::shared_ptr<const SherpaOnnxOnlineStream> stream_;
+};
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/AudioFileReader.cpp

@@ -0,0 +1,177 @@
+// ------------------------------------------------------------------------------
+// AudioFileReader.cpp
+// ------------------------------------------------------------------------------
+#include "AudioFileReader.hpp"
+
+#include <cmath>
+#include <cstring>
+#include <fstream>
+#include <stdexcept>
+
+namespace margelo::nitro::onnx::speech {
+
+namespace {
+
+constexpr int32_t kTargetSampleRate = 16000;
+
+struct WavHeader {
+  uint16_t audioFormat = 0;
+  uint16_t numChannels = 0;
+  uint32_t sampleRate = 0;
+  uint16_t bitsPerSample = 0;
+};
+
+WavHeader parseFmtChunk(const uint8_t* data, size_t size) {
+  if (size < 16) {
+    throw std::runtime_error("WAV fmt chunk too small");
+  }
+  WavHeader h;
+  std::memcpy(&h.audioFormat, data, 2);
+  std::memcpy(&h.numChannels, data + 2, 2);
+  std::memcpy(&h.sampleRate, data + 4, 4);
+  std::memcpy(&h.bitsPerSample, data + 12, 2);
+
+  if (h.audioFormat != 1 && h.audioFormat != 3) {
+    throw std::runtime_error("Unsupported WAV audio format (only PCM=1 and IEEE float=3 supported)");
+  }
+  if (h.numChannels == 0 || h.sampleRate == 0 || h.bitsPerSample == 0) {
+    throw std::runtime_error("Invalid WAV header: zero channels, sample rate, or bits per sample");
+  }
+  return h;
+}
+
+std::vector<float> decodeSamples(const uint8_t* data, size_t byteCount, uint16_t audioFormat, uint16_t bitsPerSample) {
+  if (audioFormat == 1 && bitsPerSample == 16) {
+    const size_t sampleCount = byteCount / 2;
+    std::vector<float> out(sampleCount);
+    const auto* raw = reinterpret_cast<const int16_t*>(data);
+    constexpr float scale = 1.0f / 32768.0f;
+    for (size_t i = 0; i < sampleCount; ++i) {
+      out[i] = static_cast<float>(raw[i]) * scale;
+    }
+    return out;
+  }
+  if (audioFormat == 1 && bitsPerSample == 32) {
+    const size_t sampleCount = byteCount / 4;
+    std::vector<float> out(sampleCount);
+    const auto* raw = reinterpret_cast<const int32_t*>(data);
+    constexpr float scale = 1.0f / 2147483648.0f;
+    for (size_t i = 0; i < sampleCount; ++i) {
+      out[i] = static_cast<float>(raw[i]) * scale;
+    }
+    return out;
+  }
+  if (audioFormat == 3 && bitsPerSample == 32) {
+    const size_t sampleCount = byteCount / 4;
+    std::vector<float> out(sampleCount);
+    std::memcpy(out.data(), data, sampleCount * sizeof(float));
+    return out;
+  }
+  throw std::runtime_error("Unsupported WAV sample format: format=" +
+                           std::to_string(audioFormat) + " bits=" + std::to_string(bitsPerSample));
+}
+
+std::vector<float> toMono(const std::vector<float>& samples, uint16_t channels) {
+  if (channels == 1) return samples;
+  const size_t frames = samples.size() / channels;
+  std::vector<float> out(frames);
+  const float inv = 1.0f / static_cast<float>(channels);
+  for (size_t i = 0; i < frames; ++i) {
+    float sum = 0.0f;
+    for (uint16_t c = 0; c < channels; ++c) {
+      sum += samples[i * channels + c];
+    }
+    out[i] = sum * inv;
+  }
+  return out;
+}
+
+std::vector<float> resample(const std::vector<float>& samples, uint32_t fromRate, uint32_t toRate) {
+  if (fromRate == toRate || samples.empty()) return samples;
+  const double ratio = static_cast<double>(fromRate) / static_cast<double>(toRate);
+  const size_t outSize = static_cast<size_t>(std::ceil(samples.size() / ratio));
+  std::vector<float> out(outSize);
+  for (size_t i = 0; i < outSize; ++i) {
+    const double srcPos = static_cast<double>(i) * ratio;
+    const size_t idx = static_cast<size_t>(srcPos);
+    const double frac = srcPos - static_cast<double>(idx);
+    if (idx + 1 < samples.size()) {
+      out[i] = static_cast<float>(samples[idx] * (1.0 - frac) + samples[idx + 1] * frac);
+    } else {
+      out[i] = samples[idx];
+    }
+  }
+  return out;
+}
+
+}  // namespace
+
+std::vector<float> readWavFile(const std::string& path) {
+  std::ifstream file(path, std::ios::binary);
+  if (!file) {
+    throw std::runtime_error("Cannot open WAV file: " + path);
+  }
+
+  file.seekg(0, std::ios::end);
+  const auto fileSize = file.tellg();
+  file.seekg(0, std::ios::beg);
+
+  if (fileSize < 44) {
+    throw std::runtime_error("File too small to be a valid WAV: " + path);
+  }
+
+  std::vector<uint8_t> buf(static_cast<size_t>(fileSize));
+  file.read(reinterpret_cast<char*>(buf.data()), fileSize);
+
+  if (std::memcmp(buf.data(), "RIFF", 4) != 0 || std::memcmp(buf.data() + 8, "WAVE", 4) != 0) {
+    throw std::runtime_error("Not a valid WAV file: " + path);
+  }
+
+  const uint8_t* dataChunk = nullptr;
+  size_t dataChunkSize = 0;
+  std::optional<WavHeader> header;
+
+  size_t pos = 12;
+  while (pos + 8 <= buf.size()) {
+    const char* chunkId = reinterpret_cast<const char*>(buf.data() + pos);
+    uint32_t chunkSize = 0;
+    std::memcpy(&chunkSize, buf.data() + pos + 4, 4);
+
+    if (std::memcmp(chunkId, "fmt ", 4) == 0) {
+      header = parseFmtChunk(buf.data() + pos + 8, chunkSize);
+    } else if (std::memcmp(chunkId, "data", 4) == 0) {
+      dataChunk = buf.data() + pos + 8;
+      dataChunkSize = chunkSize;
+    }
+
+    pos += 8 + chunkSize;
+    if (chunkSize % 2 != 0) ++pos;
+  }
+
+  if (!header.has_value() || dataChunk == nullptr) {
+    throw std::runtime_error("WAV file missing fmt or data chunk: " + path);
+  }
+
+  auto samples = decodeSamples(dataChunk, dataChunkSize, header->audioFormat, header->bitsPerSample);
+  samples = toMono(samples, header->numChannels);
+  samples = resample(samples, header->sampleRate, kTargetSampleRate);
+  return samples;
+}
+
+std::vector<float> readRawPcmFile(const std::string& path) {
+  std::ifstream file(path, std::ios::binary | std::ios::ate);
+  if (!file) {
+    throw std::runtime_error("Cannot open raw PCM file: " + path);
+  }
+  const auto byteCount = file.tellg();
+  if (byteCount <= 0 || static_cast<size_t>(byteCount) % sizeof(float) != 0) {
+    throw std::runtime_error("Raw PCM file size is not a multiple of sizeof(float): " + path);
+  }
+  file.seekg(0, std::ios::beg);
+  const size_t sampleCount = static_cast<size_t>(byteCount) / sizeof(float);
+  std::vector<float> samples(sampleCount);
+  file.read(reinterpret_cast<char*>(samples.data()), byteCount);
+  return samples;
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/AudioFileReader.hpp

@@ -0,0 +1,26 @@
+// ------------------------------------------------------------------------------
+// AudioFileReader.hpp
+// Minimal WAV reader that outputs 16 kHz mono f32 PCM.
+// Supports s16 and f32 sample formats; resamples from other rates via linear
+// interpolation.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::onnx::speech {
+
+/**
+ * Read a WAV file and return 16 kHz mono f32 PCM samples.
+ * Throws std::runtime_error on invalid format or I/O failure.
+ */
+std::vector<float> readWavFile(const std::string& path);
+
+/**
+ * Read a raw PCM file (16 kHz mono f32le) and return the samples directly.
+ */
+std::vector<float> readRawPcmFile(const std::string& path);
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/AudioUtils.cpp

@@ -0,0 +1,28 @@
+// ------------------------------------------------------------------------------
+// AudioUtils.cpp
+// ------------------------------------------------------------------------------
+#include "AudioUtils.hpp"
+
+#include <cstring>
+#include <stdexcept>
+
+namespace margelo::nitro::onnx::speech {
+
+std::vector<float> bytesToFloatVector(const uint8_t* data, size_t byteCount) {
+  if (byteCount % sizeof(float) != 0) {
+    throw std::invalid_argument("Audio byte count must be a multiple of sizeof(float)");
+  }
+  const size_t sampleCount = byteCount / sizeof(float);
+  std::vector<float> result(sampleCount);
+  std::memcpy(result.data(), data, byteCount);
+  return result;
+}
+
+std::vector<uint8_t> floatVectorToBytes(const std::vector<float>& samples) {
+  const size_t byteCount = samples.size() * sizeof(float);
+  std::vector<uint8_t> result(byteCount);
+  std::memcpy(result.data(), samples.data(), byteCount);
+  return result;
+}
+
+}  // namespace margelo::nitro::onnx::speech

package/cpp/AudioUtils.hpp

@@ -0,0 +1,38 @@
+// ------------------------------------------------------------------------------
+// AudioUtils.hpp
+// Helpers for converting between Nitro ArrayBuffers and sherpa-onnx float
+// sample vectors. All audio is expected to be 16 kHz mono f32 PCM.
+// ------------------------------------------------------------------------------
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace margelo::nitro::onnx::speech {
+
+/** Number of audio samples that represent one millisecond at 16 kHz. */
+constexpr float kSamplesPerMs = 16.0f;
+
+/** Convert milliseconds to sample count at 16 kHz. */
+inline int32_t msToSamples(int32_t ms) {
+  return static_cast<int32_t>(ms * kSamplesPerMs);
+}
+
+/** Convert sample count at 16 kHz to milliseconds. */
+inline float samplesToMs(int32_t samples) {
+  return static_cast<float>(samples) / kSamplesPerMs;
+}
+
+/**
+ * Copy raw bytes into a float vector.
+ * The caller must ensure the byte count is a multiple of sizeof(float).
+ */
+std::vector<float> bytesToFloatVector(const uint8_t* data, size_t byteCount);
+
+/**
+ * Copy a float vector into a newly allocated byte buffer.
+ * Returned buffer size is samples * sizeof(float).
+ */
+std::vector<uint8_t> floatVectorToBytes(const std::vector<float>& samples);
+
+}  // namespace margelo::nitro::onnx::speech