cxx-api.h

Go to the documentation of this file.

// sherpa-onnx/c-api/cxx-api.h
//
// Copyright (c)  2024  Xiaomi Corporation
#ifndef SHERPA_ONNX_C_API_CXX_API_H_
#define SHERPA_ONNX_C_API_CXX_API_H_
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "sherpa-onnx/c-api/c-api.h"
 
namespace sherpa_onnx::cxx {
 
// ============================================================================
// Streaming ASR
// ============================================================================
struct OnlineTransducerModelConfig {
  std::string encoder;
  std::string decoder;
  std::string joiner;
};
 
struct OnlineParaformerModelConfig {
  std::string encoder;
  std::string decoder;
};
 
struct OnlineZipformer2CtcModelConfig {
  std::string model;
};
 
struct OnlineNemoCtcModelConfig {
  std::string model;
};
 
struct OnlineToneCtcModelConfig {
  std::string model;
};
 
struct OnlineModelConfig {
  OnlineTransducerModelConfig transducer;
  OnlineParaformerModelConfig paraformer;
  OnlineZipformer2CtcModelConfig zipformer2_ctc;
  OnlineNemoCtcModelConfig nemo_ctc;
  OnlineToneCtcModelConfig t_one_ctc;
  std::string tokens;
  int32_t num_threads = 1;
  std::string provider = "cpu";
  bool debug = false;
  std::string model_type;
  std::string modeling_unit = "cjkchar";
  std::string bpe_vocab;
  std::string tokens_buf;
};
 
struct FeatureConfig {
  int32_t sample_rate = 16000;
  int32_t feature_dim = 80;
};
 
struct OnlineCtcFstDecoderConfig {
  std::string graph;
  int32_t max_active = 3000;
};
 
struct HomophoneReplacerConfig {
  std::string dict_dir;
  std::string lexicon;
  std::string rule_fsts;
};
 
struct OnlineRecognizerConfig {
  FeatureConfig feat_config;
  OnlineModelConfig model_config;
 
  std::string decoding_method = "greedy_search";
 
  int32_t max_active_paths = 4;
 
  bool enable_endpoint = false;
 
  float rule1_min_trailing_silence = 2.4;
 
  float rule2_min_trailing_silence = 1.2;
 
  float rule3_min_utterance_length = 20;
 
  std::string hotwords_file;
 
  float hotwords_score = 1.5;
 
  OnlineCtcFstDecoderConfig ctc_fst_decoder_config;
  std::string rule_fsts;
  std::string rule_fars;
  float blank_penalty = 0;
 
  std::string hotwords_buf;
  HomophoneReplacerConfig hr;
};
 
struct OnlineRecognizerResult {
  std::string text;
  std::vector<std::string> tokens;
  std::vector<float> timestamps;
  std::string json;
};
 
struct Wave {
  std::vector<float> samples;
  int32_t sample_rate = 0;
};
 
SHERPA_ONNX_API Wave ReadWave(const std::string &filename);
 
SHERPA_ONNX_API bool WriteWave(const std::string &filename, const Wave &wave);
 
template <typename Derived, typename T>
class SHERPA_ONNX_API MoveOnly {
 public:
  MoveOnly() = default;
  explicit MoveOnly(const T *p) : p_(p) {}
 
  ~MoveOnly() { Destroy(); }
 
  MoveOnly(const MoveOnly &) = delete;
 
  MoveOnly &operator=(const MoveOnly &) = delete;
 
  MoveOnly(MoveOnly &&other) : p_(other.Release()) {}
 
  MoveOnly &operator=(MoveOnly &&other) {
    if (&other == this) {
      return *this;
    }
 
    Destroy();
 
    p_ = other.Release();
 
    return *this;
  }
 
  const T *Get() const { return p_; }
 
  const T *Release() {
    const T *p = p_;
    p_ = nullptr;
    return p;
  }
 
 private:
  void Destroy() {
    if (p_ == nullptr) {
      return;
    }
 
    static_cast<Derived *>(this)->Destroy(p_);
 
    p_ = nullptr;
  }
 
 protected:
  const T *p_ = nullptr;
};
 
class SHERPA_ONNX_API OnlineStream
    : public MoveOnly<OnlineStream, SherpaOnnxOnlineStream> {
 public:
  explicit OnlineStream(const SherpaOnnxOnlineStream *p);
 
  void AcceptWaveform(int32_t sample_rate, const float *samples,
                      int32_t n) const;
 
  void InputFinished() const;
 
  void SetOption(const char *key, const char *value) const;
  const char *GetOption(const char *key) const;
  int32_t HasOption(const char *key) const;
 
  void Destroy(const SherpaOnnxOnlineStream *p) const;
};
 
class SHERPA_ONNX_API OnlineRecognizer
    : public MoveOnly<OnlineRecognizer, SherpaOnnxOnlineRecognizer> {
 public:
  static OnlineRecognizer Create(const OnlineRecognizerConfig &config);
 
  void Destroy(const SherpaOnnxOnlineRecognizer *p) const;
 
  OnlineStream CreateStream() const;
 
  OnlineStream CreateStream(const std::string &hotwords) const;
 
  bool IsReady(const OnlineStream *s) const;
 
  void Decode(const OnlineStream *s) const;
 
  void Decode(const OnlineStream *ss, int32_t n) const;
 
  OnlineRecognizerResult GetResult(const OnlineStream *s) const;
 
  void Reset(const OnlineStream *s) const;
 
  bool IsEndpoint(const OnlineStream *s) const;
 
 private:
  explicit OnlineRecognizer(const SherpaOnnxOnlineRecognizer *p);
};
 
// ============================================================================
// Non-streaming ASR
// ============================================================================
struct OfflineTransducerModelConfig {
  std::string encoder;
  std::string decoder;
  std::string joiner;
};
 
struct OfflineParaformerModelConfig {
  std::string model;
};
 
struct OfflineNemoEncDecCtcModelConfig {
  std::string model;
};
 
struct OfflineWhisperModelConfig {
  std::string encoder;
  std::string decoder;
  std::string language;
  std::string task = "transcribe";
  int32_t tail_paddings = -1;
  bool enable_token_timestamps = false;
  bool enable_segment_timestamps = false;
};
 
struct OfflineCanaryModelConfig {
  std::string encoder;
  std::string decoder;
  std::string src_lang;
  std::string tgt_lang;
  bool use_pnc = true;
};
 
struct OfflineCohereTranscribeModelConfig {
  std::string encoder;
  std::string decoder;
  std::string language;
  bool use_punct = true;
  bool use_itn = true;
};
 
struct OfflineFireRedAsrModelConfig {
  std::string encoder;
  std::string decoder;
};
 
struct OfflineFireRedAsrCtcModelConfig {
  std::string model;
};
 
struct OfflineTdnnModelConfig {
  std::string model;
};
 
struct OfflineSenseVoiceModelConfig {
  std::string model;
  std::string language;
  bool use_itn = false;
};
 
struct OfflineDolphinModelConfig {
  std::string model;
};
 
struct OfflineZipformerCtcModelConfig {
  std::string model;
};
 
struct OfflineWenetCtcModelConfig {
  std::string model;
};
 
struct OfflineOmnilingualAsrCtcModelConfig {
  std::string model;
};
 
struct OfflineMedAsrCtcModelConfig {
  std::string model;
};
 
struct OfflineMoonshineModelConfig {
  std::string preprocessor;
  std::string encoder;
  std::string uncached_decoder;
  std::string cached_decoder;
  std::string merged_decoder;
};
 
struct OfflineFunASRNanoModelConfig {
  std::string encoder_adaptor;
  std::string llm;
  std::string embedding;
  std::string tokenizer;
  std::string system_prompt = "You are a helpful assistant.";
  std::string user_prompt = "语音转写：";
  int32_t max_new_tokens = 512;
  float temperature = 1e-6f;
  float top_p = 0.8f;
  int32_t seed = 42;
  std::string language;
  bool itn = true;
  std::string hotwords;
};
 
struct OfflineQwen3ASRModelConfig {
  std::string conv_frontend;
  std::string encoder;
  std::string decoder;
  std::string tokenizer;
  std::string hotwords;
  int32_t max_total_len = 512;
  int32_t max_new_tokens = 128;
  float temperature = 1e-6f;
  float top_p = 0.8f;
  int32_t seed = 42;
};
 
struct OfflineModelConfig {
  OfflineTransducerModelConfig transducer;
  OfflineParaformerModelConfig paraformer;
  OfflineNemoEncDecCtcModelConfig nemo_ctc;
  OfflineWhisperModelConfig whisper;
  OfflineTdnnModelConfig tdnn;
 
  std::string tokens;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
  std::string model_type;
  std::string modeling_unit = "cjkchar";
  std::string bpe_vocab;
  std::string telespeech_ctc;
  OfflineSenseVoiceModelConfig sense_voice;
  OfflineMoonshineModelConfig moonshine;
  OfflineFireRedAsrModelConfig fire_red_asr;
  OfflineDolphinModelConfig dolphin;
  OfflineZipformerCtcModelConfig zipformer_ctc;
  OfflineCanaryModelConfig canary;
  OfflineWenetCtcModelConfig wenet_ctc;
  OfflineOmnilingualAsrCtcModelConfig omnilingual;
  OfflineMedAsrCtcModelConfig medasr;
  OfflineFunASRNanoModelConfig funasr_nano;
  OfflineFireRedAsrCtcModelConfig fire_red_asr_ctc;
  OfflineQwen3ASRModelConfig qwen3_asr;
  OfflineCohereTranscribeModelConfig cohere_transcribe;
};
 
struct OfflineLMConfig {
  std::string model;
  float scale = 1.0;
};
 
struct OfflineCtcFstDecoderConfig {
  std::string graph;
  int32_t max_active = 3000;
};
 
struct OfflineRecognizerConfig {
  FeatureConfig feat_config;
  OfflineModelConfig model_config;
  OfflineLMConfig lm_config;
 
  std::string decoding_method = "greedy_search";
  int32_t max_active_paths = 4;
 
  std::string hotwords_file;
 
  float hotwords_score = 1.5;
  std::string rule_fsts;
  std::string rule_fars;
  float blank_penalty = 0;
  HomophoneReplacerConfig hr;
  OfflineCtcFstDecoderConfig ctc_fst_decoder_config;
};
 
struct OfflineRecognizerResult {
  std::string text;
  std::vector<float> timestamps;
  std::vector<std::string> tokens;
  std::string json;
  std::string lang;
  std::string emotion;
  std::string event;
 
  std::vector<float> durations;
};
 
class SHERPA_ONNX_API OfflineStream
    : public MoveOnly<OfflineStream, SherpaOnnxOfflineStream> {
 public:
  explicit OfflineStream(const SherpaOnnxOfflineStream *p);
 
  void AcceptWaveform(int32_t sample_rate, const float *samples,
                      int32_t n) const;
 
  void SetOption(const char *key, const char *value) const;
  const char *GetOption(const char *key) const;
  int32_t HasOption(const char *key) const;
 
  void Destroy(const SherpaOnnxOfflineStream *p) const;
};
 
class SHERPA_ONNX_API OfflineRecognizer
    : public MoveOnly<OfflineRecognizer, SherpaOnnxOfflineRecognizer> {
 public:
  static OfflineRecognizer Create(const OfflineRecognizerConfig &config);
 
  void Destroy(const SherpaOnnxOfflineRecognizer *p) const;
 
  OfflineStream CreateStream() const;
 
  OfflineStream CreateStream(const std::string &hotwords) const;
 
  void Decode(const OfflineStream *s) const;
 
  void Decode(const OfflineStream *ss, int32_t n) const;
 
  OfflineRecognizerResult GetResult(const OfflineStream *s) const;
 
  std::shared_ptr<OfflineRecognizerResult> GetResultPtr(
      const OfflineStream *s) const;
 
  void SetConfig(const OfflineRecognizerConfig &config) const;
 
 private:
  explicit OfflineRecognizer(const SherpaOnnxOfflineRecognizer *p);
};
 
// ============================================================================
// Non-streaming TTS
// ============================================================================
struct OfflineTtsVitsModelConfig {
  std::string model;
  std::string lexicon;
  std::string tokens;
  std::string data_dir;
  std::string dict_dir;
 
  float noise_scale = 0.667;
  float noise_scale_w = 0.8;
  float length_scale = 1.0;
};
 
struct OfflineTtsMatchaModelConfig {
  std::string acoustic_model;
  std::string vocoder;
  std::string lexicon;
  std::string tokens;
  std::string data_dir;
  std::string dict_dir;
 
  float noise_scale = 0.667;
  float length_scale = 1.0;
};
 
struct OfflineTtsKokoroModelConfig {
  std::string model;
  std::string voices;
  std::string tokens;
  std::string data_dir;
  std::string dict_dir;
  std::string lexicon;
  std::string lang;
 
  float length_scale = 1.0;
};
 
struct OfflineTtsKittenModelConfig {
  std::string model;
  std::string voices;
  std::string tokens;
  std::string data_dir;
 
  float length_scale = 1.0;
};
 
struct OfflineTtsZipvoiceModelConfig {
  std::string tokens;
  std::string encoder;
  std::string decoder;
  std::string vocoder;
  std::string data_dir;
  std::string lexicon;
 
  float feat_scale = 0.1;
  float t_shift = 0.5;
  float target_rms = 0.1;
  float guidance_scale = 1.0;
};
 
struct OfflineTtsPocketModelConfig {
  std::string lm_flow;
  std::string lm_main;
  std::string encoder;
  std::string decoder;
  std::string text_conditioner;
 
  std::string vocab_json;
  std::string token_scores_json;
  int32_t voice_embedding_cache_capacity = 50;
};
 
struct OfflineTtsSupertonicModelConfig {
  std::string duration_predictor;
  std::string text_encoder;
  std::string vector_estimator;
  std::string vocoder;
  std::string tts_json;
  std::string unicode_indexer;
  std::string voice_style;
};
 
struct OfflineTtsModelConfig {
  OfflineTtsVitsModelConfig vits;
  OfflineTtsMatchaModelConfig matcha;
  OfflineTtsKokoroModelConfig kokoro;
  OfflineTtsKittenModelConfig kitten;
  OfflineTtsZipvoiceModelConfig zipvoice;
  OfflineTtsPocketModelConfig pocket;
  OfflineTtsSupertonicModelConfig supertonic;
 
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct GenerationConfig {
  float silence_scale = 0.2;
  float speed = 1.0;
  int32_t sid = 0;
  std::vector<float> reference_audio;
  int32_t reference_sample_rate = 0;
  std::string reference_text;
  int32_t num_steps = 5;
 
  std::unordered_map<std::string, std::string> extra;
};
 
struct OfflineTtsConfig {
  OfflineTtsModelConfig model;
  std::string rule_fsts;
  std::string rule_fars;
  int32_t max_num_sentences = 1;
  float silence_scale = 0.2;
};
 
struct GeneratedAudio {
  std::vector<float> samples;
  int32_t sample_rate = 0;
};
 
using OfflineTtsCallback = int32_t (*)(const float *samples,
                                       int32_t num_samples, float progress,
                                       void *arg);
 
class SHERPA_ONNX_API OfflineTts
    : public MoveOnly<OfflineTts, SherpaOnnxOfflineTts> {
 public:
  static OfflineTts Create(const OfflineTtsConfig &config);
 
  void Destroy(const SherpaOnnxOfflineTts *p) const;
 
  int32_t SampleRate() const;
 
  int32_t NumSpeakers() const;
 
  GeneratedAudio Generate(const std::string &text, int32_t sid = 0,
                          float speed = 1.0,
                          OfflineTtsCallback callback = nullptr,
                          void *arg = nullptr) const;
 
  GeneratedAudio Generate(const std::string &text,
                          const GenerationConfig &config,
                          OfflineTtsCallback callback = nullptr,
                          void *arg = nullptr) const;
 
  std::shared_ptr<GeneratedAudio> Generate2(
      const std::string &text, int32_t sid = 0, float speed = 1.0,
      OfflineTtsCallback callback = nullptr, void *arg = nullptr) const;
 
  std::shared_ptr<GeneratedAudio> Generate2(
      const std::string &text, const GenerationConfig &config,
      OfflineTtsCallback callback = nullptr, void *arg = nullptr) const;
 
 private:
  explicit OfflineTts(const SherpaOnnxOfflineTts *p);
};
 
// ============================================================
// For Keyword Spotter
// ============================================================
 
struct KeywordResult {
  std::string keyword;
  std::vector<std::string> tokens;
  std::vector<float> timestamps;
  float start_time = 0.0f;
  std::string json;
};
 
struct KeywordSpotterConfig {
  FeatureConfig feat_config;
  OnlineModelConfig model_config;
  int32_t max_active_paths = 4;
  int32_t num_trailing_blanks = 1;
  float keywords_score = 1.0f;
  float keywords_threshold = 0.25f;
  std::string keywords_file;
  std::string keywords_buf;
};
 
class SHERPA_ONNX_API KeywordSpotter
    : public MoveOnly<KeywordSpotter, SherpaOnnxKeywordSpotter> {
 public:
  static KeywordSpotter Create(const KeywordSpotterConfig &config);
 
  void Destroy(const SherpaOnnxKeywordSpotter *p) const;
 
  OnlineStream CreateStream() const;
 
  OnlineStream CreateStream(const std::string &keywords) const;
 
  bool IsReady(const OnlineStream *s) const;
 
  void Decode(const OnlineStream *s) const;
 
  void Decode(const OnlineStream *ss, int32_t n) const;
 
  void Reset(const OnlineStream *s) const;
 
  KeywordResult GetResult(const OnlineStream *s) const;
 
 private:
  explicit KeywordSpotter(const SherpaOnnxKeywordSpotter *p);
};
 
struct OfflineSpeechDenoiserGtcrnModelConfig {
  std::string model;
};
 
struct OfflineSpeechDenoiserDpdfNetModelConfig {
  std::string model;
  float attenuation_limit_db = 0.0f;
};
 
struct OfflineSpeechDenoiserModelConfig {
  OfflineSpeechDenoiserGtcrnModelConfig gtcrn;
  OfflineSpeechDenoiserDpdfNetModelConfig dpdfnet;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct OfflineSpeechDenoiserConfig {
  OfflineSpeechDenoiserModelConfig model;
};
 
struct DenoisedAudio {
  std::vector<float> samples;
  int32_t sample_rate = 0;
};
 
class SHERPA_ONNX_API OfflineSpeechDenoiser
    : public MoveOnly<OfflineSpeechDenoiser, SherpaOnnxOfflineSpeechDenoiser> {
 public:
  static OfflineSpeechDenoiser Create(
      const OfflineSpeechDenoiserConfig &config);
 
  void Destroy(const SherpaOnnxOfflineSpeechDenoiser *p) const;
 
  DenoisedAudio Run(const float *samples, int32_t n, int32_t sample_rate) const;
 
  int32_t GetSampleRate() const;
 
 private:
  explicit OfflineSpeechDenoiser(const SherpaOnnxOfflineSpeechDenoiser *p);
};
 
struct OnlineSpeechDenoiserConfig {
  OfflineSpeechDenoiserModelConfig model;
};
 
class SHERPA_ONNX_API OnlineSpeechDenoiser
    : public MoveOnly<OnlineSpeechDenoiser, SherpaOnnxOnlineSpeechDenoiser> {
 public:
  static OnlineSpeechDenoiser Create(const OnlineSpeechDenoiserConfig &config);
 
  void Destroy(const SherpaOnnxOnlineSpeechDenoiser *p) const;
 
  DenoisedAudio Run(const float *samples, int32_t n, int32_t sample_rate) const;
 
  DenoisedAudio Flush() const;
 
  void Reset() const;
 
  int32_t GetSampleRate() const;
 
  int32_t GetFrameShiftInSamples() const;
 
 private:
  explicit OnlineSpeechDenoiser(const SherpaOnnxOnlineSpeechDenoiser *p);
};
 
// ==============================
// VAD
// ==============================
 
struct SileroVadModelConfig {
  std::string model;
  float threshold = 0.5;
  float min_silence_duration = 0.5;
  float min_speech_duration = 0.25;
  int32_t window_size = 512;
  float max_speech_duration = 20;
};
 
struct TenVadModelConfig {
  std::string model;
  float threshold = 0.5;
  float min_silence_duration = 0.5;
  float min_speech_duration = 0.25;
  int32_t window_size = 256;
  float max_speech_duration = 20;
};
 
struct VadModelConfig {
  SileroVadModelConfig silero_vad;
  TenVadModelConfig ten_vad;
 
  int32_t sample_rate = 16000;
  int32_t num_threads = 1;
  std::string provider = "cpu";
  bool debug = false;
};
 
struct SpeechSegment {
  int32_t start = 0;
  std::vector<float> samples;
};
 
class SHERPA_ONNX_API CircularBuffer
    : public MoveOnly<CircularBuffer, SherpaOnnxCircularBuffer> {
 public:
  static CircularBuffer Create(int32_t capacity);
 
  void Destroy(const SherpaOnnxCircularBuffer *p) const;
 
  void Push(const float *p, int32_t n) const;
 
  std::vector<float> Get(int32_t start_index, int32_t n) const;
 
  void Pop(int32_t n) const;
 
  int32_t Size() const;
 
  int32_t Head() const;
 
  void Reset() const;
 
 private:
  explicit CircularBuffer(const SherpaOnnxCircularBuffer *p);
};
 
class SHERPA_ONNX_API VoiceActivityDetector
    : public MoveOnly<VoiceActivityDetector, SherpaOnnxVoiceActivityDetector> {
 public:
  static VoiceActivityDetector Create(const VadModelConfig &config,
                                      float buffer_size_in_seconds);
 
  void Destroy(const SherpaOnnxVoiceActivityDetector *p) const;
 
  void AcceptWaveform(const float *samples, int32_t n) const;
 
  bool IsEmpty() const;
 
  bool IsDetected() const;
 
  void Pop() const;
 
  void Clear() const;
 
  SpeechSegment Front() const;
 
  std::shared_ptr<SpeechSegment> FrontPtr() const;
 
  void Reset() const;
 
  void Flush() const;
 
 private:
  explicit VoiceActivityDetector(const SherpaOnnxVoiceActivityDetector *p);
};
 
class SHERPA_ONNX_API LinearResampler
    : public MoveOnly<LinearResampler, SherpaOnnxLinearResampler> {
 public:
  LinearResampler() = default;
  static LinearResampler Create(int32_t samp_rate_in_hz,
                                int32_t samp_rate_out_hz,
                                float filter_cutoff_hz, int32_t num_zeros);
 
  void Destroy(const SherpaOnnxLinearResampler *p) const;
 
  void Reset() const;
 
  std::vector<float> Resample(const float *input, int32_t input_dim,
                              bool flush) const;
 
  int32_t GetInputSamplingRate() const;
  int32_t GetOutputSamplingRate() const;
 
 private:
  explicit LinearResampler(const SherpaOnnxLinearResampler *p);
};
 
SHERPA_ONNX_API std::string GetVersionStr();
SHERPA_ONNX_API std::string GetGitSha1();
SHERPA_ONNX_API std::string GetGitDate();
SHERPA_ONNX_API std::string GetOnnxruntimeVersionStr();
SHERPA_ONNX_API bool FileExists(const std::string &filename);
 
// ============================================================================
// Offline Punctuation
// ============================================================================
struct OfflinePunctuationModelConfig {
  std::string ct_transformer;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct OfflinePunctuationConfig {
  OfflinePunctuationModelConfig model;
};
 
class SHERPA_ONNX_API OfflinePunctuation
    : public MoveOnly<OfflinePunctuation, SherpaOnnxOfflinePunctuation> {
 public:
  static OfflinePunctuation Create(const OfflinePunctuationConfig &config);
 
  void Destroy(const SherpaOnnxOfflinePunctuation *p) const;
 
  std::string AddPunctuation(const std::string &text) const;
 
 private:
  explicit OfflinePunctuation(const SherpaOnnxOfflinePunctuation *p);
};
 
// ============================================================================
// Online Punctuation
// ============================================================================
struct OnlinePunctuationModelConfig {
  std::string cnn_bilstm;
  std::string bpe_vocab;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct OnlinePunctuationConfig {
  OnlinePunctuationModelConfig model;
};
 
class SHERPA_ONNX_API OnlinePunctuation
    : public MoveOnly<OnlinePunctuation, SherpaOnnxOnlinePunctuation> {
 public:
  static OnlinePunctuation Create(const OnlinePunctuationConfig &config);
 
  void Destroy(const SherpaOnnxOnlinePunctuation *p) const;
 
  std::string AddPunctuation(const std::string &text) const;
 
 private:
  explicit OnlinePunctuation(const SherpaOnnxOnlinePunctuation *p);
};
 
// ============================================================================
// Audio tagging
// ============================================================================
struct OfflineZipformerAudioTaggingModelConfig {
  std::string model;
};
 
struct AudioTaggingModelConfig {
  OfflineZipformerAudioTaggingModelConfig zipformer;
  std::string ced;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct AudioTaggingConfig {
  AudioTaggingModelConfig model;
  std::string labels;
  int32_t top_k = 5;
};
 
struct AudioEvent {
  std::string name;
  int32_t index;
  float prob;
};
 
class SHERPA_ONNX_API AudioTagging
    : public MoveOnly<AudioTagging, SherpaOnnxAudioTagging> {
 public:
  static AudioTagging Create(const AudioTaggingConfig &config);
 
  void Destroy(const SherpaOnnxAudioTagging *p) const;
 
  OfflineStream CreateStream() const;
  std::vector<AudioEvent> Compute(const OfflineStream *s, int32_t top_k = -1);
 
  std::shared_ptr<std::vector<AudioEvent>> ComputePtr(const OfflineStream *s,
                                                      int32_t top_k = -1);
 
 private:
  explicit AudioTagging(const SherpaOnnxAudioTagging *p);
};
 
// ==============================
// Source Separation
// ==============================
 
struct OfflineSourceSeparationSpleeterModelConfig {
  std::string vocals;
  std::string accompaniment;
};
 
struct OfflineSourceSeparationUvrModelConfig {
  std::string model;
};
 
struct OfflineSourceSeparationModelConfig {
  OfflineSourceSeparationSpleeterModelConfig spleeter;
  OfflineSourceSeparationUvrModelConfig uvr;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct OfflineSourceSeparationConfig {
  OfflineSourceSeparationModelConfig model;
};
 
struct SourceSeparationStem {
  std::vector<std::vector<float>> samples;
};
 
struct SourceSeparationOutput {
  std::vector<SourceSeparationStem> stems;
  int32_t sample_rate = 0;
};
 
class SHERPA_ONNX_API OfflineSourceSeparation
    : public MoveOnly<OfflineSourceSeparation,
                      SherpaOnnxOfflineSourceSeparation> {
 public:
  static OfflineSourceSeparation Create(
      const OfflineSourceSeparationConfig &config);
 
  void Destroy(const SherpaOnnxOfflineSourceSeparation *p) const;
 
  SourceSeparationOutput Process(const float *const *samples,
                                 int32_t num_channels, int32_t num_samples,
                                 int32_t sample_rate) const;
 
  int32_t GetOutputSampleRate() const;
 
  int32_t GetNumberOfStems() const;
 
 private:
  explicit OfflineSourceSeparation(const SherpaOnnxOfflineSourceSeparation *p);
};
 
// ============================================================================
// Spoken Language Identification
// ============================================================================
 
struct SpokenLanguageIdentificationWhisperConfig {
  std::string encoder;
  std::string decoder;
  int32_t tail_paddings = 0;
};
 
struct SpokenLanguageIdentificationConfig {
  SpokenLanguageIdentificationWhisperConfig whisper;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct SpokenLanguageIdentificationResult {
  std::string lang;
};
 
class SHERPA_ONNX_API SpokenLanguageIdentification
    : public MoveOnly<SpokenLanguageIdentification,
                      SherpaOnnxSpokenLanguageIdentification> {
 public:
  static SpokenLanguageIdentification Create(
      const SpokenLanguageIdentificationConfig &config);
 
  void Destroy(const SherpaOnnxSpokenLanguageIdentification *p) const;
 
  OfflineStream CreateStream() const;
 
  SpokenLanguageIdentificationResult Compute(const OfflineStream *s) const;
 
 private:
  explicit SpokenLanguageIdentification(
      const SherpaOnnxSpokenLanguageIdentification *p);
};
 
// ============================================================================
// Speaker Embedding Extractor
// ============================================================================
 
struct SpeakerEmbeddingExtractorConfig {
  std::string model;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
class SHERPA_ONNX_API SpeakerEmbeddingExtractor
    : public MoveOnly<SpeakerEmbeddingExtractor,
                      SherpaOnnxSpeakerEmbeddingExtractor> {
 public:
  static SpeakerEmbeddingExtractor Create(
      const SpeakerEmbeddingExtractorConfig &config);
 
  void Destroy(const SherpaOnnxSpeakerEmbeddingExtractor *p) const;
 
  int32_t Dim() const;
 
  OnlineStream CreateStream() const;
 
  bool IsReady(const OnlineStream *s) const;
 
  std::vector<float> ComputeEmbedding(const OnlineStream *s) const;
 
 private:
  explicit SpeakerEmbeddingExtractor(
      const SherpaOnnxSpeakerEmbeddingExtractor *p);
};
 
// ============================================================================
// Speaker Embedding Manager
// ============================================================================
 
struct SpeakerMatch {
  float score;
  std::string name;
};
 
class SHERPA_ONNX_API SpeakerEmbeddingManager
    : public MoveOnly<SpeakerEmbeddingManager,
                      SherpaOnnxSpeakerEmbeddingManager> {
 public:
  static SpeakerEmbeddingManager Create(int32_t dim);
 
  void Destroy(const SherpaOnnxSpeakerEmbeddingManager *p) const;
 
  bool Add(const std::string &name, const float *v) const;
 
  bool AddList(const std::string &name, const float **v) const;
 
  bool AddListFlattened(const std::string &name, const float *v,
                        int32_t n) const;
 
  bool Remove(const std::string &name) const;
 
  std::string Search(const float *v, float threshold) const;
 
  std::vector<SpeakerMatch> GetBestMatches(const float *v, float threshold,
                                           int32_t n) const;
 
  bool Verify(const std::string &name, const float *v, float threshold) const;
 
  bool Contains(const std::string &name) const;
 
  int32_t NumSpeakers() const;
 
  int32_t Dim() const;
 
  std::vector<std::string> GetAllSpeakers() const;
 
  std::vector<float> GetEmbedding(const std::string &name) const;
 
 private:
  explicit SpeakerEmbeddingManager(const SherpaOnnxSpeakerEmbeddingManager *p);
};
 
// ============================================================================
// Offline Speaker Diarization
// ============================================================================
 
struct OfflineSpeakerSegmentationPyannoteModelConfig {
  std::string model;
  float window_shift_ratio = 0.1f;
};
 
struct OfflineSpeakerSegmentationModelConfig {
  OfflineSpeakerSegmentationPyannoteModelConfig pyannote;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct FastClusteringConfig {
  int32_t num_clusters = 0;
  float threshold = 0.5;
  bool compute_confidence = false;
};
 
struct OfflineSpeakerDiarizationConfig {
  OfflineSpeakerSegmentationModelConfig segmentation;
  SpeakerEmbeddingExtractorConfig embedding;
  FastClusteringConfig clustering;
  float min_duration_on = 0;
  float min_duration_off = 0;
};
 
struct OfflineSpeakerDiarizationSegment {
  static constexpr float kUnavailableConfidence = -2.0f;
 
  float start;
  float end;
  int32_t speaker;
  float confidence = kUnavailableConfidence;
};
 
using OfflineSpeakerDiarizationProgressCallback =
    std::function<void(int32_t num_processed_chunks, int32_t num_total_chunks)>;
 
class SHERPA_ONNX_API OfflineSpeakerDiarization
    : public MoveOnly<OfflineSpeakerDiarization,
                      SherpaOnnxOfflineSpeakerDiarization> {
 public:
  static OfflineSpeakerDiarization Create(
      const OfflineSpeakerDiarizationConfig &config);
 
  void Destroy(const SherpaOnnxOfflineSpeakerDiarization *p) const;
 
  int32_t GetSampleRate() const;
 
  void SetConfig(const OfflineSpeakerDiarizationConfig &config) const;
 
  std::vector<OfflineSpeakerDiarizationSegment> Process(
      const float *samples, int32_t n) const;
 
  std::vector<OfflineSpeakerDiarizationSegment> Process(
      const float *samples, int32_t n,
      const OfflineSpeakerDiarizationProgressCallback &callback) const;
 
 private:
  explicit OfflineSpeakerDiarization(
      const SherpaOnnxOfflineSpeakerDiarization *p);
};
 
// ============================================================================
// Offline Diacritization
// ============================================================================
struct OfflineDiacritizationModelConfig {
  std::string catt_encoder;
  std::string catt_decoder;
  int32_t num_threads = 1;
  bool debug = false;
  std::string provider = "cpu";
};
 
struct OfflineDiacritizationConfig {
  OfflineDiacritizationModelConfig model;
};
 
class SHERPA_ONNX_API OfflineDiacritization
    : public MoveOnly<OfflineDiacritization, SherpaOnnxOfflineDiacritization> {
 public:
  static OfflineDiacritization Create(const OfflineDiacritizationConfig &config);
 
  void Destroy(const SherpaOnnxOfflineDiacritization *diacrt) const;
 
  std::string AddDiacritics(const std::string &text) const;
 
 private:
  explicit OfflineDiacritization(const SherpaOnnxOfflineDiacritization *diacrt);
};
 
}  // namespace sherpa_onnx::cxx
 
#endif  // SHERPA_ONNX_C_API_CXX_API_H_