mirror of
https://github.com/k2-fsa/sherpa-onnx.git
synced 2026-11-10 21:11:03 +08:00
Improve C/C++ API documentation, examples, and CI (#3626)
This commit is contained in:
Fangjun Kuang authored and 
GitHub committed
1 parent
6acf367a39
commit
a703cf6560
69 files changed
+5192
-2042
No files matched your search
@@ -18,13 +18,13 @@ log "------------------------------------------------------------"
|
||||
log "Test adding punctuations "
|
||||
log "------------------------------------------------------------"
|
||||
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/punctuation-models/sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/punctuation-models/sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
ls -lh
|
||||
tar xf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
ls -lh sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12
|
||||
rm sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
tar xf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
ls -lh sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8
|
||||
rm sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
$PUNCT_EXE
|
||||
rm -rf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12
|
||||
rm -rf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8
|
||||
|
||||
log "------------------------------------------------------------"
|
||||
log "Test audio tagging "
|
||||
|
||||
@@ -34,9 +34,9 @@ rm -rf sherpa-onnx-whisper-tiny.en
|
||||
log "------------------------------------------------------------"
|
||||
log "Test SenseVoice CXX API"
|
||||
log "------------------------------------------------------------"
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
|
||||
$CXX_SENSE_VOICE_EXE
|
||||
rm -rf sherpa-onnx-sense-voice-*
|
||||
@@ -249,7 +249,7 @@ rm -rf /tmp/test-cluster
|
||||
export GIT_CLONE_PROTECTION_ACTIVE=false
|
||||
|
||||
log "test offline SenseVoice CTC"
|
||||
url=https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
url=https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
name=$(basename $url)
|
||||
repo=$(basename -s .tar.bz2 $name)
|
||||
|
||||
@@ -279,7 +279,7 @@ if [[ $(uname) == Linux ]]; then
|
||||
|
||||
python3 ./python-api-examples/generate-subtitles.py \
|
||||
--silero-vad-model=./silero_vad.onnx \
|
||||
--sense-voice=$repo/model.onnx \
|
||||
--sense-voice=$repo/model.int8.onnx \
|
||||
--tokens=$repo/tokens.txt \
|
||||
--num-threads=2 \
|
||||
./lei-jun-test.wav
|
||||
@@ -293,7 +293,7 @@ if [[ $(uname) == Linux ]]; then
|
||||
|
||||
python3 ./python-api-examples/generate-subtitles.py \
|
||||
--silero-vad-model=./silero_vad.onnx \
|
||||
--sense-voice=$repo/model.onnx \
|
||||
--sense-voice=$repo/model.int8.onnx \
|
||||
--tokens=$repo/tokens.txt \
|
||||
--num-threads=2 \
|
||||
./Obama.wav
|
||||
|
||||
+1044
-808
File diff suppressed because it is too large.
Load diff
+849
-821
File diff suppressed because it is too large.
Load diff
@@ -97,6 +97,12 @@ target_link_libraries(cohere-transcribe-c-api sherpa-onnx-c-api)
|
||||
add_executable(nemo-parakeet-c-api nemo-parakeet-c-api.c)
|
||||
target_link_libraries(nemo-parakeet-c-api sherpa-onnx-c-api)
|
||||
|
||||
add_executable(nemo-giga-am-v2-c-api nemo-giga-am-v2-c-api.c)
|
||||
target_link_libraries(nemo-giga-am-v2-c-api sherpa-onnx-c-api)
|
||||
|
||||
add_executable(nemo-ctc-c-api nemo-ctc-c-api.c)
|
||||
target_link_libraries(nemo-ctc-c-api sherpa-onnx-c-api)
|
||||
|
||||
add_executable(sense-voice-c-api sense-voice-c-api.c)
|
||||
target_link_libraries(sense-voice-c-api sherpa-onnx-c-api)
|
||||
|
||||
@@ -136,6 +142,9 @@ target_link_libraries(fire-red-asr-ctc-c-api sherpa-onnx-c-api)
|
||||
add_executable(streaming-zipformer-c-api streaming-zipformer-c-api.c)
|
||||
target_link_libraries(streaming-zipformer-c-api sherpa-onnx-c-api)
|
||||
|
||||
add_executable(streaming-nemotron-c-api streaming-nemotron-c-api.c)
|
||||
target_link_libraries(streaming-nemotron-c-api sherpa-onnx-c-api)
|
||||
|
||||
add_executable(streaming-zipformer-with-hr-c-api streaming-zipformer-with-hr-c-api.c)
|
||||
target_link_libraries(streaming-zipformer-with-hr-c-api sherpa-onnx-c-api)
|
||||
|
||||
|
||||
@@ -9,9 +9,9 @@
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/punctuation-models/sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
// tar xvf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
// rm sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/punctuation-models/sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
// tar xvf sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
// rm sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -26,7 +26,7 @@ int32_t main() {
|
||||
memset(&config, 0, sizeof(config));
|
||||
|
||||
// clang-format off
|
||||
config.model.ct_transformer = "./sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12/model.onnx";
|
||||
config.model.ct_transformer = "./sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8/model.int8.onnx";
|
||||
// clang-format on
|
||||
config.model.num_threads = 1;
|
||||
config.model.debug = 1;
|
||||
|
||||
@@ -34,24 +34,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineFireRedAsrCtcModelConfig fire_red_asr_ctc;
|
||||
memset(&fire_red_asr_ctc, 0, sizeof(fire_red_asr_ctc));
|
||||
fire_red_asr_ctc.model = model_filename;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.fire_red_asr_ctc = fire_red_asr_ctc;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.fire_red_asr_ctc.model = model_filename;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -33,26 +33,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineFunASRNanoModelConfig funasr_nano;
|
||||
memset(&funasr_nano, 0, sizeof(funasr_nano));
|
||||
funasr_nano.encoder_adaptor = encoder_adaptor;
|
||||
funasr_nano.embedding = embedding;
|
||||
funasr_nano.llm = llm;
|
||||
funasr_nano.tokenizer = tokenizer;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 2;
|
||||
offline_model_config.provider = "cpu";
|
||||
offline_model_config.funasr_nano = funasr_nano;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 2;
|
||||
recognizer_config.model_config.provider = "cpu";
|
||||
recognizer_config.model_config.funasr_nano.encoder_adaptor = encoder_adaptor;
|
||||
recognizer_config.model_config.funasr_nano.embedding = embedding;
|
||||
recognizer_config.model_config.funasr_nano.llm = llm;
|
||||
recognizer_config.model_config.funasr_nano.tokenizer = tokenizer;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -89,30 +89,20 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOnlineTransducerModelConfig zipformer_config;
|
||||
memset(&zipformer_config, 0, sizeof(zipformer_config));
|
||||
zipformer_config.encoder = encoder_filename;
|
||||
zipformer_config.decoder = decoder_filename;
|
||||
zipformer_config.joiner = joiner_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens_buf = tokens_buf;
|
||||
online_model_config.tokens_buf_size = token_buf_size;
|
||||
online_model_config.transducer = zipformer_config;
|
||||
|
||||
// Keywords-spotter config
|
||||
SherpaOnnxKeywordSpotterConfig keywords_spotter_config;
|
||||
memset(&keywords_spotter_config, 0, sizeof(keywords_spotter_config));
|
||||
keywords_spotter_config.max_active_paths = 4;
|
||||
keywords_spotter_config.keywords_threshold = 0.1;
|
||||
keywords_spotter_config.keywords_score = 3.0;
|
||||
keywords_spotter_config.model_config = online_model_config;
|
||||
keywords_spotter_config.model_config.debug = 1;
|
||||
keywords_spotter_config.model_config.num_threads = 1;
|
||||
keywords_spotter_config.model_config.provider = provider;
|
||||
keywords_spotter_config.model_config.tokens_buf = tokens_buf;
|
||||
keywords_spotter_config.model_config.tokens_buf_size = token_buf_size;
|
||||
keywords_spotter_config.model_config.transducer.encoder = encoder_filename;
|
||||
keywords_spotter_config.model_config.transducer.decoder = decoder_filename;
|
||||
keywords_spotter_config.model_config.transducer.joiner = joiner_filename;
|
||||
keywords_spotter_config.keywords_buf = keywords_buf;
|
||||
keywords_spotter_config.keywords_buf_size = keywords_buf_size;
|
||||
|
||||
|
||||
@@ -34,24 +34,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineMedAsrCtcModelConfig medasr;
|
||||
memset(&medasr, 0, sizeof(medasr));
|
||||
medasr.model = model_filename;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.medasr = medasr;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.medasr.model = model_filename;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
// c-api-examples/nemo-ctc-c-api.c
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use NeMo CTC model with sherpa-onnx's C API.
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
// rm sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sherpa-onnx/c-api/c-api.h"
|
||||
|
||||
int32_t main() {
|
||||
// clang-format off
|
||||
const char *wav_filename = "./sherpa-onnx-nemo-ctc-en-citrinet-512/test_wavs/0.wav";
|
||||
const char *model_filename = "./sherpa-onnx-nemo-ctc-en-citrinet-512/model.onnx";
|
||||
const char *tokens_filename = "./sherpa-onnx-nemo-ctc-en-citrinet-512/tokens.txt";
|
||||
// clang-format on
|
||||
|
||||
const SherpaOnnxWave *wave = SherpaOnnxReadWave(wav_filename);
|
||||
if (wave == NULL) {
|
||||
fprintf(stderr, "Failed to read %s\n", wav_filename);
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = "cpu";
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.nemo_ctc.model = model_filename;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
if (recognizer == NULL) {
|
||||
fprintf(stderr, "Please check your config!\n");
|
||||
SherpaOnnxFreeWave(wave);
|
||||
return -1;
|
||||
}
|
||||
|
||||
const SherpaOnnxOfflineStream *stream =
|
||||
SherpaOnnxCreateOfflineStream(recognizer);
|
||||
|
||||
SherpaOnnxAcceptWaveformOffline(stream, wave->sample_rate, wave->samples,
|
||||
wave->num_samples);
|
||||
SherpaOnnxDecodeOfflineStream(recognizer, stream);
|
||||
const SherpaOnnxOfflineRecognizerResult *result =
|
||||
SherpaOnnxGetOfflineStreamResult(stream);
|
||||
|
||||
fprintf(stderr, "Decoded text: %s\n", result->text);
|
||||
|
||||
SherpaOnnxDestroyOfflineRecognizerResult(result);
|
||||
SherpaOnnxDestroyOfflineStream(stream);
|
||||
SherpaOnnxDestroyOfflineRecognizer(recognizer);
|
||||
SherpaOnnxFreeWave(wave);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
// c-api-examples/nemo-giga-am-v2-c-api.c
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use the NeMo transducer GigaAM v2 model
|
||||
// with sherpa-onnx's C API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
// rm sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sherpa-onnx/c-api/c-api.h"
|
||||
|
||||
int32_t main() {
|
||||
const char *wav_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"test_wavs/example.wav";
|
||||
const char *encoder_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"encoder.int8.onnx";
|
||||
const char *decoder_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"decoder.onnx";
|
||||
const char *joiner_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"joiner.onnx";
|
||||
const char *tokens_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"tokens.txt";
|
||||
const char *provider = "cpu";
|
||||
|
||||
if (!SherpaOnnxFileExists(wav_filename)) {
|
||||
fprintf(stderr, "File not found: %s\n", wav_filename);
|
||||
return -1;
|
||||
}
|
||||
const SherpaOnnxWave *wave = SherpaOnnxReadWave(wav_filename);
|
||||
if (wave == NULL) {
|
||||
fprintf(stderr, "Failed to read or parse %s\n", wav_filename);
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 0;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.transducer.encoder = encoder_filename;
|
||||
offline_model_config.transducer.decoder = decoder_filename;
|
||||
offline_model_config.transducer.joiner = joiner_filename;
|
||||
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
if (recognizer == NULL) {
|
||||
fprintf(stderr, "Please check your config!\n");
|
||||
SherpaOnnxFreeWave(wave);
|
||||
return -1;
|
||||
}
|
||||
|
||||
const SherpaOnnxOfflineStream *stream =
|
||||
SherpaOnnxCreateOfflineStream(recognizer);
|
||||
|
||||
SherpaOnnxAcceptWaveformOffline(stream, wave->sample_rate, wave->samples,
|
||||
wave->num_samples);
|
||||
SherpaOnnxDecodeOfflineStream(recognizer, stream);
|
||||
const SherpaOnnxOfflineRecognizerResult *result =
|
||||
SherpaOnnxGetOfflineStreamResult(stream);
|
||||
|
||||
printf("Recognized text: %s\n", result->text);
|
||||
|
||||
SherpaOnnxDestroyOfflineRecognizerResult(result);
|
||||
SherpaOnnxDestroyOfflineStream(stream);
|
||||
SherpaOnnxDestroyOfflineRecognizer(recognizer);
|
||||
SherpaOnnxFreeWave(wave);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -34,24 +34,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineOmnilingualAsrCtcModelConfig omnilingual;
|
||||
memset(&omnilingual, 0, sizeof(omnilingual));
|
||||
omnilingual.model = model_filename;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.omnilingual = omnilingual;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.omnilingual.model = model_filename;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -34,25 +34,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Paraformer config
|
||||
SherpaOnnxOfflineParaformerModelConfig paraformer_config;
|
||||
memset(¶former_config, 0, sizeof(paraformer_config));
|
||||
paraformer_config.model = model_filename;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.paraformer = paraformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.paraformer.model = model_filename;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -44,30 +44,22 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineQwen3ASRModelConfig qwen3;
|
||||
memset(&qwen3, 0, sizeof(qwen3));
|
||||
qwen3.conv_frontend = conv_frontend;
|
||||
qwen3.encoder = encoder;
|
||||
qwen3.decoder = decoder;
|
||||
qwen3.tokenizer = tokenizer;
|
||||
qwen3.max_total_len = 512;
|
||||
qwen3.max_new_tokens = 128;
|
||||
qwen3.temperature = 1e-6f;
|
||||
qwen3.top_p = 0.8f;
|
||||
qwen3.seed = 42;
|
||||
qwen3.hotwords = ""; // optional; e.g. "foo,bar"
|
||||
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 2;
|
||||
offline_model_config.provider = "cpu";
|
||||
offline_model_config.qwen3_asr = qwen3;
|
||||
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 2;
|
||||
recognizer_config.model_config.provider = "cpu";
|
||||
recognizer_config.model_config.qwen3_asr.conv_frontend = conv_frontend;
|
||||
recognizer_config.model_config.qwen3_asr.encoder = encoder;
|
||||
recognizer_config.model_config.qwen3_asr.decoder = decoder;
|
||||
recognizer_config.model_config.qwen3_asr.tokenizer = tokenizer;
|
||||
recognizer_config.model_config.qwen3_asr.max_total_len = 512;
|
||||
recognizer_config.model_config.qwen3_asr.max_new_tokens = 128;
|
||||
recognizer_config.model_config.qwen3_asr.temperature = 1e-6f;
|
||||
recognizer_config.model_config.qwen3_asr.top_p = 0.8f;
|
||||
recognizer_config.model_config.qwen3_asr.seed = 42;
|
||||
recognizer_config.model_config.qwen3_asr.hotwords = ""; // optional; e.g. "foo,bar"
|
||||
|
||||
const SherpaOnnxOfflineRecognizer* recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -6,9 +6,9 @@
|
||||
// This file demonstrates how to use SenseVoice with sherpa-onnx's C API.
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -20,11 +20,11 @@
|
||||
|
||||
int32_t main() {
|
||||
const char *wav_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/en.wav";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/en.wav";
|
||||
const char *model_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
const char *tokens_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
const char *language = "auto";
|
||||
const char *provider = "cpu";
|
||||
int32_t use_inverse_text_normalization = 1;
|
||||
@@ -35,26 +35,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineSenseVoiceModelConfig sense_voice_config;
|
||||
memset(&sense_voice_config, 0, sizeof(sense_voice_config));
|
||||
sense_voice_config.model = model_filename;
|
||||
sense_voice_config.language = language;
|
||||
sense_voice_config.use_itn = use_inverse_text_normalization;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.sense_voice = sense_voice_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.sense_voice.model = model_filename;
|
||||
recognizer_config.model_config.sense_voice.language = language;
|
||||
recognizer_config.model_config.sense_voice.use_itn = use_inverse_text_normalization;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
// with homophone replacer.
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/hr-files/dict.tar.bz2
|
||||
// tar xf dict.tar.bz2
|
||||
@@ -29,9 +29,9 @@
|
||||
int32_t main() {
|
||||
const char *wav_filename = "./test-hr.wav";
|
||||
const char *model_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
const char *tokens_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
const char *language = "auto";
|
||||
const char *provider = "cpu";
|
||||
int32_t use_inverse_text_normalization = 1;
|
||||
@@ -42,26 +42,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineSenseVoiceModelConfig sense_voice_config;
|
||||
memset(&sense_voice_config, 0, sizeof(sense_voice_config));
|
||||
sense_voice_config.model = model_filename;
|
||||
sense_voice_config.language = language;
|
||||
sense_voice_config.use_itn = use_inverse_text_normalization;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.sense_voice = sense_voice_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.sense_voice.model = model_filename;
|
||||
recognizer_config.model_config.sense_voice.language = language;
|
||||
recognizer_config.model_config.sense_voice.use_itn = use_inverse_text_normalization;
|
||||
recognizer_config.hr.dict_dir = "./dict";
|
||||
recognizer_config.hr.lexicon = "./lexicon.txt";
|
||||
|
||||
|
||||
@@ -74,26 +74,16 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer2Ctc config
|
||||
SherpaOnnxOnlineZipformer2CtcModelConfig zipformer2_ctc_config;
|
||||
memset(&zipformer2_ctc_config, 0, sizeof(zipformer2_ctc_config));
|
||||
zipformer2_ctc_config.model = model_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens_buf = tokens_buf;
|
||||
online_model_config.tokens_buf_size = token_buf_size;
|
||||
online_model_config.zipformer2_ctc = zipformer2_ctc_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens_buf = tokens_buf;
|
||||
recognizer_config.model_config.tokens_buf_size = token_buf_size;
|
||||
recognizer_config.model_config.zipformer2_ctc.model = model_filename;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
// c-api-examples/streaming-nemotron-c-api.c
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use streaming Nemotron with sherpa-onnx's C
|
||||
// API.
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
// rm sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sherpa-onnx/c-api/c-api.h"
|
||||
|
||||
int32_t main() {
|
||||
const char *wav_filename =
|
||||
"sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"test_wavs/0.wav";
|
||||
const char *encoder_filename =
|
||||
"sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"encoder.int8.onnx";
|
||||
const char *decoder_filename =
|
||||
"sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"decoder.int8.onnx";
|
||||
const char *joiner_filename =
|
||||
"sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"joiner.int8.onnx";
|
||||
const char *tokens_filename =
|
||||
"sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"tokens.txt";
|
||||
const char *provider = "cpu";
|
||||
|
||||
const SherpaOnnxWave *wave = SherpaOnnxReadWave(wav_filename);
|
||||
if (wave == NULL) {
|
||||
fprintf(stderr, "Failed to read %s\n", wav_filename);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.transducer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.transducer.decoder = decoder_filename;
|
||||
recognizer_config.model_config.transducer.joiner = joiner_filename;
|
||||
recognizer_config.enable_endpoint = 1;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&recognizer_config);
|
||||
|
||||
if (recognizer == NULL) {
|
||||
fprintf(stderr, "Please check your config!\n");
|
||||
SherpaOnnxFreeWave(wave);
|
||||
return -1;
|
||||
}
|
||||
|
||||
const SherpaOnnxOnlineStream *stream =
|
||||
SherpaOnnxCreateOnlineStream(recognizer);
|
||||
|
||||
const SherpaOnnxDisplay *display = SherpaOnnxCreateDisplay(50);
|
||||
int32_t segment_id = 0;
|
||||
|
||||
// simulate streaming. You can choose an arbitrary N
|
||||
#define N 3200
|
||||
|
||||
fprintf(stderr, "sample rate: %d, num samples: %d, duration: %.2f s\n",
|
||||
wave->sample_rate, wave->num_samples,
|
||||
(float)wave->num_samples / wave->sample_rate);
|
||||
|
||||
int32_t k = 0;
|
||||
while (k < wave->num_samples) {
|
||||
int32_t start = k;
|
||||
int32_t end =
|
||||
(start + N > wave->num_samples) ? wave->num_samples : (start + N);
|
||||
k += N;
|
||||
|
||||
SherpaOnnxOnlineStreamAcceptWaveform(stream, wave->sample_rate,
|
||||
wave->samples + start, end - start);
|
||||
while (SherpaOnnxIsOnlineStreamReady(recognizer, stream)) {
|
||||
SherpaOnnxDecodeOnlineStream(recognizer, stream);
|
||||
}
|
||||
|
||||
const SherpaOnnxOnlineRecognizerResult *r =
|
||||
SherpaOnnxGetOnlineStreamResult(recognizer, stream);
|
||||
|
||||
if (strlen(r->text)) {
|
||||
SherpaOnnxPrint(display, segment_id, r->text);
|
||||
}
|
||||
|
||||
if (SherpaOnnxOnlineStreamIsEndpoint(recognizer, stream)) {
|
||||
if (strlen(r->text)) {
|
||||
++segment_id;
|
||||
}
|
||||
SherpaOnnxOnlineStreamReset(recognizer, stream);
|
||||
}
|
||||
|
||||
SherpaOnnxDestroyOnlineRecognizerResult(r);
|
||||
}
|
||||
|
||||
// add some tail padding
|
||||
float tail_paddings[4800] = {0}; // 0.3 seconds at 16 kHz sample rate
|
||||
SherpaOnnxOnlineStreamAcceptWaveform(stream, wave->sample_rate, tail_paddings,
|
||||
4800);
|
||||
|
||||
SherpaOnnxFreeWave(wave);
|
||||
|
||||
SherpaOnnxOnlineStreamInputFinished(stream);
|
||||
while (SherpaOnnxIsOnlineStreamReady(recognizer, stream)) {
|
||||
SherpaOnnxDecodeOnlineStream(recognizer, stream);
|
||||
}
|
||||
|
||||
const SherpaOnnxOnlineRecognizerResult *r =
|
||||
SherpaOnnxGetOnlineStreamResult(recognizer, stream);
|
||||
|
||||
if (strlen(r->text)) {
|
||||
SherpaOnnxPrint(display, segment_id, r->text);
|
||||
}
|
||||
|
||||
SherpaOnnxDestroyOnlineRecognizerResult(r);
|
||||
|
||||
SherpaOnnxDestroyDisplay(display);
|
||||
SherpaOnnxDestroyOnlineStream(stream);
|
||||
SherpaOnnxDestroyOnlineRecognizer(recognizer);
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -74,27 +74,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Paraformer config
|
||||
SherpaOnnxOnlineParaformerModelConfig paraformer_config;
|
||||
memset(¶former_config, 0, sizeof(paraformer_config));
|
||||
paraformer_config.encoder = encoder_filename;
|
||||
paraformer_config.decoder = decoder_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens_buf = tokens_buf;
|
||||
online_model_config.tokens_buf_size = token_buf_size;
|
||||
online_model_config.paraformer = paraformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens_buf = tokens_buf;
|
||||
recognizer_config.model_config.tokens_buf_size = token_buf_size;
|
||||
recognizer_config.model_config.paraformer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.paraformer.decoder = decoder_filename;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -36,26 +36,16 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Paraformer config
|
||||
SherpaOnnxOnlineParaformerModelConfig paraformer_config;
|
||||
memset(¶former_config, 0, sizeof(paraformer_config));
|
||||
paraformer_config.encoder = encoder_filename;
|
||||
paraformer_config.decoder = decoder_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens = tokens_filename;
|
||||
online_model_config.paraformer = paraformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.paraformer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.paraformer.decoder = decoder_filename;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -34,25 +34,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOnlineToneCtcModelConfig t_one_ctc;
|
||||
memset(&t_one_ctc, 0, sizeof(t_one_ctc));
|
||||
t_one_ctc.model = model;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens = tokens;
|
||||
online_model_config.t_one_ctc = t_one_ctc;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens;
|
||||
recognizer_config.model_config.t_one_ctc.model = model;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
// API and with tokens and hotwords loaded from buffered strings instead of from
|
||||
// external files API.
|
||||
// clang-format off
|
||||
//
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-zipformer-en-20M-2023-02-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-streaming-zipformer-en-20M-2023-02-17.tar.bz2
|
||||
// rm sherpa-onnx-streaming-zipformer-en-20M-2023-02-17.tar.bz2
|
||||
@@ -91,28 +91,18 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOnlineTransducerModelConfig zipformer_config;
|
||||
memset(&zipformer_config, 0, sizeof(zipformer_config));
|
||||
zipformer_config.encoder = encoder_filename;
|
||||
zipformer_config.decoder = decoder_filename;
|
||||
zipformer_config.joiner = joiner_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens_buf = tokens_buf;
|
||||
online_model_config.tokens_buf_size = token_buf_size;
|
||||
online_model_config.transducer = zipformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "modified_beam_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens_buf = tokens_buf;
|
||||
recognizer_config.model_config.tokens_buf_size = token_buf_size;
|
||||
recognizer_config.model_config.transducer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.transducer.decoder = decoder_filename;
|
||||
recognizer_config.model_config.transducer.joiner = joiner_filename;
|
||||
recognizer_config.hotwords_buf = hotwords_buf;
|
||||
recognizer_config.hotwords_buf_size = hotwords_buf_size;
|
||||
|
||||
|
||||
@@ -41,27 +41,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOnlineTransducerModelConfig zipformer_config;
|
||||
memset(&zipformer_config, 0, sizeof(zipformer_config));
|
||||
zipformer_config.encoder = encoder_filename;
|
||||
zipformer_config.decoder = decoder_filename;
|
||||
zipformer_config.joiner = joiner_filename;
|
||||
|
||||
// Online model config
|
||||
SherpaOnnxOnlineModelConfig online_model_config;
|
||||
memset(&online_model_config, 0, sizeof(online_model_config));
|
||||
online_model_config.debug = 1;
|
||||
online_model_config.num_threads = 1;
|
||||
online_model_config.provider = provider;
|
||||
online_model_config.tokens = tokens_filename;
|
||||
online_model_config.transducer = zipformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOnlineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = online_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.transducer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.transducer.decoder = decoder_filename;
|
||||
recognizer_config.model_config.transducer.joiner = joiner_filename;
|
||||
recognizer_config.enable_endpoint = 1;
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
|
||||
@@ -14,9 +14,9 @@
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/lei-jun-test.wav
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -51,9 +51,9 @@ int32_t main() {
|
||||
}
|
||||
|
||||
const char *model_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
const char *tokens_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
const char *language = "auto";
|
||||
const char *provider = "cpu";
|
||||
int32_t use_inverse_text_normalization = 1;
|
||||
@@ -71,26 +71,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineSenseVoiceModelConfig sense_voice_config;
|
||||
memset(&sense_voice_config, 0, sizeof(sense_voice_config));
|
||||
sense_voice_config.model = model_filename;
|
||||
sense_voice_config.language = language;
|
||||
sense_voice_config.use_itn = use_inverse_text_normalization;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 0;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.sense_voice = sense_voice_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 0;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.sense_voice.model = model_filename;
|
||||
recognizer_config.model_config.sense_voice.language = language;
|
||||
recognizer_config.model_config.sense_voice.use_itn = use_inverse_text_normalization;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -33,25 +33,15 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOfflineWenetCtcModelConfig wenet_ctc_config;
|
||||
memset(&wenet_ctc_config, 0, sizeof(wenet_ctc_config));
|
||||
wenet_ctc_config.model = model;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens;
|
||||
offline_model_config.wenet_ctc = wenet_ctc_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens;
|
||||
recognizer_config.model_config.wenet_ctc.model = model;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -34,29 +34,19 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Whisper config
|
||||
SherpaOnnxOfflineWhisperModelConfig whisper_config;
|
||||
memset(&whisper_config, 0, sizeof(whisper_config));
|
||||
whisper_config.decoder = decoder_filename;
|
||||
whisper_config.encoder = encoder_filename;
|
||||
whisper_config.language = language;
|
||||
whisper_config.tail_paddings = 0;
|
||||
whisper_config.task = "transcribe";
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.whisper = whisper_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.whisper.decoder = decoder_filename;
|
||||
recognizer_config.model_config.whisper.encoder = encoder_filename;
|
||||
recognizer_config.model_config.whisper.language = language;
|
||||
recognizer_config.model_config.whisper.tail_paddings = 0;
|
||||
recognizer_config.model_config.whisper.task = "transcribe";
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -38,27 +38,17 @@ int32_t main() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Zipformer config
|
||||
SherpaOnnxOfflineTransducerModelConfig zipformer_config;
|
||||
memset(&zipformer_config, 0, sizeof(zipformer_config));
|
||||
zipformer_config.encoder = encoder_filename;
|
||||
zipformer_config.decoder = decoder_filename;
|
||||
zipformer_config.joiner = joiner_filename;
|
||||
|
||||
// Offline model config
|
||||
SherpaOnnxOfflineModelConfig offline_model_config;
|
||||
memset(&offline_model_config, 0, sizeof(offline_model_config));
|
||||
offline_model_config.debug = 1;
|
||||
offline_model_config.num_threads = 1;
|
||||
offline_model_config.provider = provider;
|
||||
offline_model_config.tokens = tokens_filename;
|
||||
offline_model_config.transducer = zipformer_config;
|
||||
|
||||
// Recognizer config
|
||||
SherpaOnnxOfflineRecognizerConfig recognizer_config;
|
||||
memset(&recognizer_config, 0, sizeof(recognizer_config));
|
||||
recognizer_config.decoding_method = "greedy_search";
|
||||
recognizer_config.model_config = offline_model_config;
|
||||
recognizer_config.model_config.debug = 1;
|
||||
recognizer_config.model_config.num_threads = 1;
|
||||
recognizer_config.model_config.provider = provider;
|
||||
recognizer_config.model_config.tokens = tokens_filename;
|
||||
recognizer_config.model_config.transducer.encoder = encoder_filename;
|
||||
recognizer_config.model_config.transducer.decoder = decoder_filename;
|
||||
recognizer_config.model_config.transducer.joiner = joiner_filename;
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&recognizer_config);
|
||||
|
||||
@@ -3,6 +3,9 @@ include_directories(${PROJECT_SOURCE_DIR})
|
||||
add_executable(streaming-zipformer-cxx-api ./streaming-zipformer-cxx-api.cc)
|
||||
target_link_libraries(streaming-zipformer-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(streaming-nemotron-cxx-api ./streaming-nemotron-cxx-api.cc)
|
||||
target_link_libraries(streaming-nemotron-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(streaming-zipformer-with-hr-cxx-api ./streaming-zipformer-with-hr-cxx-api.cc)
|
||||
target_link_libraries(streaming-zipformer-with-hr-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
@@ -73,6 +76,30 @@ target_link_libraries(medasr-ctc-cxx-api sherpa-onnx-cxx-api)
|
||||
add_executable(nemo-canary-cxx-api ./nemo-canary-cxx-api.cc)
|
||||
target_link_libraries(nemo-canary-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(nemo-giga-am-v2-cxx-api ./nemo-giga-am-v2-cxx-api.cc)
|
||||
target_link_libraries(nemo-giga-am-v2-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(nemo-ctc-cxx-api ./nemo-ctc-cxx-api.cc)
|
||||
target_link_libraries(nemo-ctc-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(paraformer-cxx-api ./paraformer-cxx-api.cc)
|
||||
target_link_libraries(paraformer-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(streaming-paraformer-cxx-api ./streaming-paraformer-cxx-api.cc)
|
||||
target_link_libraries(streaming-paraformer-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(spoken-language-identification-cxx-api
|
||||
./spoken-language-identification-cxx-api.cc)
|
||||
target_link_libraries(spoken-language-identification-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(speaker-identification-cxx-api
|
||||
./speaker-identification-cxx-api.cc)
|
||||
target_link_libraries(speaker-identification-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(offline-speaker-diarization-cxx-api
|
||||
./offline-speaker-diarization-cxx-api.cc)
|
||||
target_link_libraries(offline-speaker-diarization-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(cohere-transcribe-cxx-api ./cohere-transcribe-cxx-api.cc)
|
||||
target_link_libraries(cohere-transcribe-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
@@ -222,4 +249,7 @@ if(SHERPA_ONNX_ENABLE_TTS)
|
||||
|
||||
add_executable(zipvoice-tts-zh-en-cxx-api ./zipvoice-tts-zh-en-cxx-api.cc)
|
||||
target_link_libraries(zipvoice-tts-zh-en-cxx-api sherpa-onnx-cxx-api)
|
||||
|
||||
add_executable(offline-tts-piper-cxx-api ./offline-tts-piper-cxx-api.cc)
|
||||
target_link_libraries(offline-tts-piper-cxx-api sherpa-onnx-cxx-api)
|
||||
endif()
|
||||
@@ -0,0 +1,76 @@
|
||||
// cxx-api-examples/nemo-ctc-cxx-api.cc
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use NeMo CTC model with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
// rm sherpa-onnx-nemo-ctc-en-citrinet-512.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <chrono> // NOLINT
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
// clang-format off
|
||||
config.model_config.nemo_ctc.model = "./sherpa-onnx-nemo-ctc-en-citrinet-512/model.onnx"; // NOLINT
|
||||
config.model_config.tokens = "./sherpa-onnx-nemo-ctc-en-citrinet-512/tokens.txt"; // NOLINT
|
||||
|
||||
std::string wave_filename = "./sherpa-onnx-nemo-ctc-en-citrinet-512/test_wavs/0.wav"; // NOLINT
|
||||
// clang-format on
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
|
||||
std::cout << "Loading model\n";
|
||||
OfflineRecognizer recognizer = OfflineRecognizer::Create(config);
|
||||
if (!recognizer.Get()) {
|
||||
std::cerr << "Please check your config\n";
|
||||
return -1;
|
||||
}
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wave_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "Start recognition\n";
|
||||
const auto begin = std::chrono::steady_clock::now();
|
||||
|
||||
OfflineStream stream = recognizer.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
|
||||
recognizer.Decode(&stream);
|
||||
|
||||
OfflineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
|
||||
const auto end = std::chrono::steady_clock::now();
|
||||
const float elapsed_seconds =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(end - begin)
|
||||
.count() /
|
||||
1000.;
|
||||
float duration = wave.samples.size() / static_cast<float>(wave.sample_rate);
|
||||
float rtf = elapsed_seconds / duration;
|
||||
|
||||
std::cout << "text: " << result.text << "\n";
|
||||
printf("Number of threads: %d\n", config.model_config.num_threads);
|
||||
printf("Duration: %.3fs\n", duration);
|
||||
printf("Elapsed seconds: %.3fs\n", elapsed_seconds);
|
||||
printf("(Real time factor) RTF = %.3f / %.3f = %.3f\n", elapsed_seconds,
|
||||
duration, rtf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
// cxx-api-examples/nemo-giga-am-v2-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use the NeMo transducer GigaAM v2 model
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
// rm sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <chrono> // NOLINT
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"encoder.int8.onnx";
|
||||
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"decoder.onnx";
|
||||
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"joiner.onnx";
|
||||
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
|
||||
std::cout << "Loading model\n";
|
||||
OfflineRecognizer recognizer = OfflineRecognizer::Create(config);
|
||||
if (!recognizer.Get()) {
|
||||
std::cerr << "Please check your config\n";
|
||||
return -1;
|
||||
}
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
std::string wave_filename =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"test_wavs/example.wav";
|
||||
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wave_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "Start recognition\n";
|
||||
const auto begin = std::chrono::steady_clock::now();
|
||||
|
||||
OfflineStream stream = recognizer.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
|
||||
recognizer.Decode(&stream);
|
||||
|
||||
OfflineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
|
||||
const auto end = std::chrono::steady_clock::now();
|
||||
const float elapsed_seconds =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(end - begin)
|
||||
.count() /
|
||||
1000.;
|
||||
float duration = wave.samples.size() / static_cast<float>(wave.sample_rate);
|
||||
float rtf = elapsed_seconds / duration;
|
||||
|
||||
std::cout << "text: " << result.text << "\n";
|
||||
printf("Number of threads: %d\n", config.model_config.num_threads);
|
||||
printf("Duration: %.3fs\n", duration);
|
||||
printf("Elapsed seconds: %.3fs\n", elapsed_seconds);
|
||||
printf("(Real time factor) RTF = %.3f / %.3f = %.3f\n", elapsed_seconds,
|
||||
duration, rtf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
// cxx-api-examples/offline-speaker-diarization-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use offline speaker diarization
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/sherpa-onnx-pyannote-segmentation-3-0.tar.bz2
|
||||
// tar xvf sherpa-onnx-pyannote-segmentation-3-0.tar.bz2
|
||||
// rm sherpa-onnx-pyannote-segmentation-3-0.tar.bz2
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/0-four-speakers-zh.wav
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
|
||||
OfflineSpeakerDiarizationConfig config;
|
||||
config.segmentation.pyannote.model =
|
||||
"./sherpa-onnx-pyannote-segmentation-3-0/model.onnx";
|
||||
config.embedding.model =
|
||||
"./3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx";
|
||||
config.clustering.num_clusters = 4;
|
||||
|
||||
OfflineSpeakerDiarization sd = OfflineSpeakerDiarization::Create(config);
|
||||
if (!sd.Get()) {
|
||||
std::cerr << "Failed to create speaker diarization\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
Wave wave = ReadWave("./0-four-speakers-zh.wav");
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read wave file\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::vector<OfflineSpeakerDiarizationSegment> segments =
|
||||
sd.Process(wave.samples.data(), wave.samples.size());
|
||||
|
||||
for (const auto &seg : segments) {
|
||||
printf("%.3f -- %.3f speaker_%02d\n", seg.start, seg.end, seg.speaker);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
// cxx-api-examples/offline-tts-piper-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
// This file shows how to use sherpa-onnx CXX API
|
||||
// for English TTS with a Piper VITS model.
|
||||
//
|
||||
// clang-format off
|
||||
/*
|
||||
Usage
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-en_US-lessac-medium.tar.bz2
|
||||
tar xf vits-piper-en_US-lessac-medium.tar.bz2
|
||||
rm vits-piper-en_US-lessac-medium.tar.bz2
|
||||
|
||||
./offline-tts-piper-cxx-api
|
||||
|
||||
*/
|
||||
// clang-format on
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
static int32_t ProgressCallback(const float *samples, int32_t num_samples,
|
||||
float progress, void *arg) {
|
||||
fprintf(stderr, "Progress: %.3f%%\n", progress * 100);
|
||||
// return 1 to continue generating
|
||||
// return 0 to stop generating
|
||||
return 1;
|
||||
}
|
||||
|
||||
int32_t main(int32_t argc, char *argv[]) {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OfflineTtsConfig config;
|
||||
|
||||
config.model.vits.model =
|
||||
"./vits-piper-en_US-lessac-medium/en_US-lessac-medium.onnx";
|
||||
config.model.vits.tokens = "./vits-piper-en_US-lessac-medium/tokens.txt";
|
||||
config.model.vits.data_dir =
|
||||
"./vits-piper-en_US-lessac-medium/espeak-ng-data";
|
||||
|
||||
config.model.num_threads = 1;
|
||||
|
||||
// If you don't want to see debug messages, please set it to 0
|
||||
config.model.debug = true;
|
||||
|
||||
std::string filename = "./generated-piper-en-cxx.wav";
|
||||
std::string text =
|
||||
"Today as always, men fall into two groups: slaves and free men. Whoever "
|
||||
"does not have two-thirds of his day for himself, is a slave, whatever "
|
||||
"he may be: a statesman, a businessman, an official, or a scholar. "
|
||||
"Friends fell out often because life was changing so fast. The easiest "
|
||||
"thing in the world was to lose touch with someone.";
|
||||
|
||||
auto tts = OfflineTts::Create(config);
|
||||
GenerationConfig gen_config;
|
||||
gen_config.sid = 0;
|
||||
gen_config.speed = 1.0; // larger -> faster in speech speed
|
||||
gen_config.silence_scale = 0.2f;
|
||||
|
||||
#if 0
|
||||
// If you don't want to use a callback, then please enable this branch
|
||||
GeneratedAudio audio = tts.Generate(text, gen_config);
|
||||
#else
|
||||
GeneratedAudio audio = tts.Generate(text, gen_config, ProgressCallback);
|
||||
#endif
|
||||
|
||||
WriteWave(filename, {audio.samples, audio.sample_rate});
|
||||
|
||||
fprintf(stderr, "Input text is: %s\n", text.c_str());
|
||||
fprintf(stderr, "Speaker ID is: %d\n", gen_config.sid);
|
||||
fprintf(stderr, "Saved to: %s\n", filename.c_str());
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
// cxx-api-examples/paraformer-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use non-streaming Paraformer
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-paraformer-zh-small-2024-03-09.tar.bz2
|
||||
// tar xvf sherpa-onnx-paraformer-zh-small-2024-03-09.tar.bz2
|
||||
// rm sherpa-onnx-paraformer-zh-small-2024-03-09.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <chrono> // NOLINT
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.paraformer.model =
|
||||
"./sherpa-onnx-paraformer-zh-small-2024-03-09/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-paraformer-zh-small-2024-03-09/tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
config.model_config.debug = true;
|
||||
|
||||
std::cout << "Loading model\n";
|
||||
OfflineRecognizer recognizer = OfflineRecognizer::Create(config);
|
||||
if (!recognizer.Get()) {
|
||||
std::cerr << "Please check your config\n";
|
||||
return -1;
|
||||
}
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
std::string wave_filename =
|
||||
"./sherpa-onnx-paraformer-zh-small-2024-03-09/test_wavs/0.wav";
|
||||
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wave_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "Start recognition\n";
|
||||
const auto begin = std::chrono::steady_clock::now();
|
||||
|
||||
OfflineStream stream = recognizer.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
|
||||
recognizer.Decode(&stream);
|
||||
|
||||
OfflineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
|
||||
const auto end = std::chrono::steady_clock::now();
|
||||
const float elapsed_seconds =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(end - begin)
|
||||
.count() /
|
||||
1000.;
|
||||
float duration = wave.samples.size() / static_cast<float>(wave.sample_rate);
|
||||
float rtf = elapsed_seconds / duration;
|
||||
|
||||
std::cout << "text: " << result.text << "\n";
|
||||
printf("Number of threads: %d\n", config.model_config.num_threads);
|
||||
printf("Duration: %.3fs\n", duration);
|
||||
printf("Elapsed seconds: %.3fs\n", elapsed_seconds);
|
||||
printf("(Real time factor) RTF = %.3f / %.3f = %.3f\n", elapsed_seconds,
|
||||
duration, rtf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -6,9 +6,9 @@
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -24,11 +24,11 @@ int32_t main() {
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.sense_voice.model =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
config.model_config.sense_voice.use_itn = true;
|
||||
config.model_config.sense_voice.language = "auto";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
|
||||
@@ -41,7 +41,7 @@ int32_t main() {
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
std::string wave_filename =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/en.wav";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/en.wav";
|
||||
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
|
||||
@@ -9,9 +9,9 @@
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -80,11 +80,11 @@ static sherpa_onnx::cxx::OfflineRecognizer CreateOfflineRecognizer() {
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.sense_voice.model =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
config.model_config.sense_voice.use_itn = false;
|
||||
config.model_config.sense_voice.language = "auto";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 2;
|
||||
config.model_config.debug = false;
|
||||
@@ -105,9 +105,9 @@ Usage:
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
|
||||
./sense-voice-simulate-streaming-alsa-cxx-api device_name
|
||||
|
||||
|
||||
@@ -9,9 +9,9 @@
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
@@ -83,11 +83,11 @@ static sherpa_onnx::cxx::OfflineRecognizer CreateOfflineRecognizer() {
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.sense_voice.model =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
config.model_config.sense_voice.use_itn = false;
|
||||
config.model_config.sense_voice.language = "auto";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 2;
|
||||
config.model_config.debug = false;
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
// rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/hr-files/dict.tar.bz2
|
||||
// tar xf dict.tar.bz2
|
||||
@@ -32,11 +32,11 @@ int32_t main() {
|
||||
OfflineRecognizerConfig config;
|
||||
|
||||
config.model_config.sense_voice.model =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx";
|
||||
config.model_config.sense_voice.use_itn = true;
|
||||
config.model_config.sense_voice.language = "auto";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt";
|
||||
config.hr.dict_dir = "./dict";
|
||||
config.hr.lexicon = "./lexicon.txt";
|
||||
|
||||
|
||||
@@ -0,0 +1,105 @@
|
||||
// cxx-api-examples/speaker-identification-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use speaker embedding extraction and
|
||||
// speaker identification with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_campplus_sv_zh-cn_16k-common.onnx
|
||||
//
|
||||
// Also download test data from https://github.com/csukuangfj/sr-data
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
static std::vector<float> ComputeEmbedding(
|
||||
const sherpa_onnx::cxx::SpeakerEmbeddingExtractor &ex,
|
||||
const std::string &wav_filename) {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
Wave wave = ReadWave(wav_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read " << wav_filename << "\n";
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
OnlineStream stream = ex.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
stream.InputFinished();
|
||||
|
||||
if (!ex.IsReady(&stream)) {
|
||||
std::cerr << "The input wave file " << wav_filename << " is too short!\n";
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return ex.ComputeEmbedding(&stream);
|
||||
}
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
SpeakerEmbeddingExtractorConfig config;
|
||||
config.model = "./3dspeaker_speech_campplus_sv_zh-cn_16k-common.onnx";
|
||||
config.num_threads = 1;
|
||||
|
||||
SpeakerEmbeddingExtractor ex = SpeakerEmbeddingExtractor::Create(config);
|
||||
if (!ex.Get()) {
|
||||
std::cerr << "Failed to create speaker embedding extractor\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
int32_t dim = ex.Dim();
|
||||
std::cout << "Embedding dimension: " << dim << "\n";
|
||||
|
||||
SpeakerEmbeddingManager manager = SpeakerEmbeddingManager::Create(dim);
|
||||
|
||||
// Enroll speakers
|
||||
std::vector<std::vector<float>> spk1_embeddings;
|
||||
spk1_embeddings.push_back(ComputeEmbedding(ex, "./sr-data/enroll/fangjun-sr-1.wav"));
|
||||
spk1_embeddings.push_back(ComputeEmbedding(ex, "./sr-data/enroll/fangjun-sr-2.wav"));
|
||||
spk1_embeddings.push_back(ComputeEmbedding(ex, "./sr-data/enroll/fangjun-sr-3.wav"));
|
||||
|
||||
std::vector<std::vector<float>> spk2_embeddings;
|
||||
spk2_embeddings.push_back(ComputeEmbedding(ex, "./sr-data/enroll/leijun-sr-1.wav"));
|
||||
spk2_embeddings.push_back(ComputeEmbedding(ex, "./sr-data/enroll/leijun-sr-2.wav"));
|
||||
|
||||
const float *spk1_vec[4] = {spk1_embeddings[0].data(),
|
||||
spk1_embeddings[1].data(),
|
||||
spk1_embeddings[2].data(), nullptr};
|
||||
const float *spk2_vec[3] = {spk2_embeddings[0].data(),
|
||||
spk2_embeddings[1].data(), nullptr};
|
||||
|
||||
manager.AddList("fangjun", spk1_vec);
|
||||
manager.AddList("leijun", spk2_vec);
|
||||
|
||||
std::cout << "Enrolled speakers: " << manager.NumSpeakers() << "\n";
|
||||
|
||||
// Search
|
||||
float threshold = 0.6f;
|
||||
|
||||
auto v1 = ComputeEmbedding(ex, "./sr-data/test/fangjun-test-sr-1.wav");
|
||||
std::string name1 = manager.Search(v1.data(), threshold);
|
||||
std::cout << "fangjun-test-sr-1.wav: " << (name1.empty() ? "unknown" : name1)
|
||||
<< "\n";
|
||||
|
||||
auto v2 = ComputeEmbedding(ex, "./sr-data/test/leijun-test-sr-1.wav");
|
||||
std::string name2 = manager.Search(v2.data(), threshold);
|
||||
std::cout << "leijun-test-sr-1.wav: " << (name2.empty() ? "unknown" : name2)
|
||||
<< "\n";
|
||||
|
||||
// Verify
|
||||
bool ok = manager.Verify("fangjun", v1.data(), threshold);
|
||||
std::cout << "fangjun-test-sr-1.wav matches fangjun: "
|
||||
<< (ok ? "yes" : "no") << "\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
// cxx-api-examples/spoken-language-identification-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use spoken language identification
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-whisper-tiny.tar.bz2
|
||||
// tar xvf sherpa-onnx-whisper-tiny.tar.bz2
|
||||
// rm sherpa-onnx-whisper-tiny.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
|
||||
SpokenLanguageIdentificationConfig config;
|
||||
config.whisper.encoder = "./sherpa-onnx-whisper-tiny/tiny-encoder.int8.onnx";
|
||||
config.whisper.decoder = "./sherpa-onnx-whisper-tiny/tiny-decoder.int8.onnx";
|
||||
config.num_threads = 1;
|
||||
|
||||
SpokenLanguageIdentification slid =
|
||||
SpokenLanguageIdentification::Create(config);
|
||||
if (!slid.Get()) {
|
||||
std::cerr << "Failed to create spoken language identifier\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::string wav_filename = "./sherpa-onnx-whisper-tiny/test_wavs/0.wav";
|
||||
Wave wave = ReadWave(wav_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wav_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
OfflineStream stream = slid.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
|
||||
SpokenLanguageIdentificationResult result = slid.Compute(&stream);
|
||||
|
||||
std::cout << "Detected language: " << result.lang << "\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// cxx-api-examples/streaming-nemotron-cxx-api.cc
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use streaming Nemotron
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
// tar xvf sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
// rm sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <chrono> // NOLINT
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OnlineRecognizerConfig config;
|
||||
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"encoder.int8.onnx";
|
||||
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"decoder.int8.onnx";
|
||||
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"joiner.int8.onnx";
|
||||
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
|
||||
std::cout << "Loading model\n";
|
||||
OnlineRecognizer recognizer = OnlineRecognizer::Create(config);
|
||||
if (!recognizer.Get()) {
|
||||
std::cerr << "Please check your config\n";
|
||||
return -1;
|
||||
}
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
std::string wave_filename =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"test_wavs/0.wav";
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wave_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "Start recognition\n";
|
||||
const auto begin = std::chrono::steady_clock::now();
|
||||
|
||||
OnlineStream stream = recognizer.CreateStream();
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data(),
|
||||
wave.samples.size());
|
||||
stream.InputFinished();
|
||||
|
||||
while (recognizer.IsReady(&stream)) {
|
||||
recognizer.Decode(&stream);
|
||||
}
|
||||
|
||||
OnlineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
|
||||
const auto end = std::chrono::steady_clock::now();
|
||||
const float elapsed_seconds =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(end - begin)
|
||||
.count() /
|
||||
1000.;
|
||||
float duration = wave.samples.size() / static_cast<float>(wave.sample_rate);
|
||||
float rtf = elapsed_seconds / duration;
|
||||
|
||||
std::cout << "text: " << result.text << "\n";
|
||||
printf("Number of threads: %d\n", config.model_config.num_threads);
|
||||
printf("Duration: %.3fs\n", duration);
|
||||
printf("Elapsed seconds: %.3fs\n", elapsed_seconds);
|
||||
printf("(Real time factor) RTF = %.3f / %.3f = %.3f\n", elapsed_seconds,
|
||||
duration, rtf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
// cxx-api-examples/streaming-paraformer-cxx-api.cc
|
||||
//
|
||||
// Copyright (c) 2026 Xiaomi Corporation
|
||||
|
||||
//
|
||||
// This file demonstrates how to use streaming Paraformer
|
||||
// with sherpa-onnx's C++ API.
|
||||
//
|
||||
// clang-format off
|
||||
//
|
||||
// wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2
|
||||
// tar xvf sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2
|
||||
// rm sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2
|
||||
//
|
||||
// clang-format on
|
||||
|
||||
#include <chrono> // NOLINT
|
||||
#include <cstdio>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "sherpa-onnx/c-api/cxx-api.h"
|
||||
|
||||
int32_t main() {
|
||||
using namespace sherpa_onnx::cxx; // NOLINT
|
||||
OnlineRecognizerConfig config;
|
||||
|
||||
config.model_config.paraformer.encoder =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/encoder.int8.onnx";
|
||||
config.model_config.paraformer.decoder =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/decoder.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/tokens.txt";
|
||||
|
||||
config.model_config.num_threads = 1;
|
||||
config.model_config.debug = true;
|
||||
config.enable_endpoint = true;
|
||||
|
||||
std::cout << "Loading model\n";
|
||||
OnlineRecognizer recognizer = OnlineRecognizer::Create(config);
|
||||
if (!recognizer.Get()) {
|
||||
std::cerr << "Please check your config\n";
|
||||
return -1;
|
||||
}
|
||||
std::cout << "Loading model done\n";
|
||||
|
||||
std::string wave_filename =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/test_wavs/0.wav";
|
||||
Wave wave = ReadWave(wave_filename);
|
||||
if (wave.samples.empty()) {
|
||||
std::cerr << "Failed to read: '" << wave_filename << "'\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << "Start recognition\n";
|
||||
const auto begin = std::chrono::steady_clock::now();
|
||||
|
||||
OnlineStream stream = recognizer.CreateStream();
|
||||
|
||||
// simulate streaming. You can choose an arbitrary N
|
||||
const int32_t n = 3200;
|
||||
int32_t k = 0;
|
||||
int32_t segment_id = 0;
|
||||
|
||||
fprintf(stderr, "sample rate: %d, num samples: %d, duration: %.2f s\n",
|
||||
wave.sample_rate, static_cast<int32_t>(wave.samples.size()),
|
||||
static_cast<float>(wave.samples.size()) / wave.sample_rate);
|
||||
|
||||
while (k < static_cast<int32_t>(wave.samples.size())) {
|
||||
int32_t start = k;
|
||||
int32_t end = std::min(start + n, static_cast<int32_t>(wave.samples.size()));
|
||||
k += n;
|
||||
|
||||
stream.AcceptWaveform(wave.sample_rate, wave.samples.data() + start,
|
||||
end - start);
|
||||
while (recognizer.IsReady(&stream)) {
|
||||
recognizer.Decode(&stream);
|
||||
}
|
||||
|
||||
OnlineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
|
||||
if (!result.text.empty()) {
|
||||
fprintf(stderr, "%d: %s\n", segment_id, result.text.c_str());
|
||||
}
|
||||
|
||||
if (recognizer.IsEndpoint(&stream)) {
|
||||
if (!result.text.empty()) {
|
||||
++segment_id;
|
||||
}
|
||||
recognizer.Reset(&stream);
|
||||
}
|
||||
}
|
||||
|
||||
// add some tail padding
|
||||
float tail_paddings[4800] = {0}; // 0.3 seconds at 16 kHz sample rate
|
||||
stream.AcceptWaveform(wave.sample_rate, tail_paddings, 4800);
|
||||
|
||||
stream.InputFinished();
|
||||
while (recognizer.IsReady(&stream)) {
|
||||
recognizer.Decode(&stream);
|
||||
}
|
||||
|
||||
OnlineRecognizerResult result = recognizer.GetResult(&stream);
|
||||
if (!result.text.empty()) {
|
||||
fprintf(stderr, "%d: %s\n", segment_id, result.text.c_str());
|
||||
}
|
||||
|
||||
const auto end_time = std::chrono::steady_clock::now();
|
||||
const float elapsed_seconds =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(end_time - begin)
|
||||
.count() /
|
||||
1000.;
|
||||
float duration = wave.samples.size() / static_cast<float>(wave.sample_rate);
|
||||
float rtf = elapsed_seconds / duration;
|
||||
|
||||
printf("Number of threads: %d\n", config.model_config.num_threads);
|
||||
printf("Duration: %.3fs\n", duration);
|
||||
printf("Elapsed seconds: %.3fs\n", elapsed_seconds);
|
||||
printf("(Real time factor) RTF = %.3f / %.3f = %.3f\n", elapsed_seconds,
|
||||
duration, rtf);
|
||||
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -80,8 +80,8 @@ Please replace --silero-vad-model with --ten-vad-model below to use ten-vad.
|
||||
|
||||
./python-api-examples/generate-subtitles.py \
|
||||
--silero-vad-model=/path/to/silero_vad.onnx \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt \
|
||||
--num-threads=2 \
|
||||
/path/to/test.mp4
|
||||
|
||||
|
||||
@@ -109,13 +109,13 @@ python3 ./python-api-examples/non_streaming_server.py \
|
||||
|
||||
(8) Use a Non-streaming SenseVoice model
|
||||
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
|
||||
python3 ./python-api-examples/non_streaming_server.py \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt
|
||||
|
||||
(9) Use a Non-streaming telespeech ctc model
|
||||
|
||||
|
||||
@@ -10,9 +10,9 @@ https://github.com/k2-fsa/sherpa-onnx/releases/tag/asr-models
|
||||
|
||||
For instance,
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/hr-files/dict.tar.bz2
|
||||
tar xf dict.tar.bz2
|
||||
@@ -29,8 +29,8 @@ import soundfile as sf
|
||||
|
||||
|
||||
def create_recognizer():
|
||||
model = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx"
|
||||
tokens = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt"
|
||||
model = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx"
|
||||
tokens = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt"
|
||||
test_wav = "./test-hr.wav"
|
||||
|
||||
if not Path(model).is_file() or not Path(test_wav).is_file():
|
||||
|
||||
@@ -10,9 +10,9 @@ https://github.com/k2-fsa/sherpa-onnx/releases/tag/asr-models
|
||||
|
||||
For instance,
|
||||
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
tar xvf sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
rm sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
@@ -22,13 +22,13 @@ import soundfile as sf
|
||||
|
||||
|
||||
def create_recognizer():
|
||||
model = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx"
|
||||
tokens = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt"
|
||||
test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/zh.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/en.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/ja.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/ko.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/test_wavs/yue.wav"
|
||||
model = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx"
|
||||
tokens = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt"
|
||||
test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/zh.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/en.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/ja.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/ko.wav"
|
||||
# test_wav = "./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/test_wavs/yue.wav"
|
||||
|
||||
if not Path(model).is_file() or not Path(test_wav).is_file():
|
||||
raise ValueError(
|
||||
|
||||
@@ -14,8 +14,8 @@ wget https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_v
|
||||
|
||||
./python-api-examples/simulate-streaming-sense-voice-microphone.py \
|
||||
--silero-vad-model=./silero_vad.onnx \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt
|
||||
"""
|
||||
import argparse
|
||||
import queue
|
||||
|
||||
@@ -42,13 +42,13 @@ python3 ./python-api-examples/two-pass-wss.py \
|
||||
--paraformer-encoder ./sherpa-onnx-streaming-paraformer-bilingual-zh-en/encoder.onnx \
|
||||
--paraformer-decoder ./sherpa-onnx-streaming-paraformer-bilingual-zh-en/decoder.onnx \
|
||||
--tokens ./sherpa-onnx-streaming-paraformer-bilingual-zh-en/tokens.txt \
|
||||
--second-sense-voice ./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx \
|
||||
--second-tokens ./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt \
|
||||
--second-sense-voice ./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx \
|
||||
--second-tokens ./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt \
|
||||
--certificate ./python-api-examples/web/cert.pem
|
||||
|
||||
Please refer to
|
||||
https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-streaming-paraformer-bilingual-zh-en.tar.bz2
|
||||
https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17.tar.bz2
|
||||
https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17.tar.bz2
|
||||
to download pre-trained models.
|
||||
"""
|
||||
|
||||
|
||||
@@ -60,8 +60,8 @@ Note that you need a non-streaming model for this script.
|
||||
|
||||
./python-api-examples/vad-with-non-streaming-asr.py \
|
||||
--silero-vad-model=/path/to/silero_vad.onnx \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/model.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt \
|
||||
--sense-voice=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/model.int8.onnx \
|
||||
--tokens=./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt \
|
||||
--num-threads=2
|
||||
|
||||
Please refer to
|
||||
|
||||
@@ -96,9 +96,23 @@ WARN_LOGFILE =
|
||||
|
||||
INPUT = mainpage.md \
|
||||
c-api.h \
|
||||
cxx-api.h
|
||||
cxx-api.h \
|
||||
docs/offline-asr.dox \
|
||||
docs/online-asr.dox \
|
||||
docs/tts.dox \
|
||||
docs/vad.dox \
|
||||
docs/audio-tagging.dox \
|
||||
docs/punctuation.dox \
|
||||
docs/speech-enhancement.dox \
|
||||
docs/source-separation.dox \
|
||||
docs/speaker-diarization.dox \
|
||||
docs/speaker-embedding.dox \
|
||||
docs/spoken-language-id.dox \
|
||||
docs/keyword-spotting.dox \
|
||||
docs/resampler.dox
|
||||
INPUT_ENCODING = UTF-8
|
||||
FILE_PATTERNS = *.h
|
||||
FILE_PATTERNS = *.h \
|
||||
*.dox
|
||||
RECURSIVE = NO
|
||||
EXCLUDE =
|
||||
EXCLUDE_SYMLINKS = NO
|
||||
|
||||
@@ -333,6 +333,7 @@ typedef struct SherpaOnnxHomophoneReplacerConfig {
|
||||
*
|
||||
* config.decoding_method = "greedy_search";
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOnlineRecognizer
|
||||
*/
|
||||
typedef struct SherpaOnnxOnlineRecognizerConfig {
|
||||
/** Feature extraction settings. */
|
||||
@@ -387,6 +388,7 @@ typedef struct SherpaOnnxOnlineRecognizerConfig {
|
||||
* All pointers in this struct are owned by the result object returned from
|
||||
* SherpaOnnxGetOnlineStreamResult() and become invalid after
|
||||
* SherpaOnnxDestroyOnlineRecognizerResult() is called.
|
||||
* @see SherpaOnnxGetOnlineStreamResult
|
||||
*/
|
||||
typedef struct SherpaOnnxOnlineRecognizerResult {
|
||||
/** Recognized text accumulated so far. */
|
||||
@@ -457,6 +459,7 @@ typedef struct SherpaOnnxOnlineStream SherpaOnnxOnlineStream;
|
||||
* const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
* SherpaOnnxCreateOnlineRecognizer(&config);
|
||||
* @endcode
|
||||
* @see SherpaOnnxOnlineRecognizerConfig, SherpaOnnxDestroyOnlineRecognizer
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOnlineRecognizer *
|
||||
SherpaOnnxCreateOnlineRecognizer(
|
||||
@@ -471,6 +474,7 @@ SherpaOnnxCreateOnlineRecognizer(
|
||||
* SherpaOnnxDestroyOnlineRecognizer(recognizer);
|
||||
* recognizer = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOnlineRecognizer
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOnlineRecognizer(
|
||||
const SherpaOnnxOnlineRecognizer *recognizer);
|
||||
@@ -491,6 +495,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOnlineRecognizer(
|
||||
* const SherpaOnnxOnlineStream *stream =
|
||||
* SherpaOnnxCreateOnlineStream(recognizer);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyOnlineStream
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOnlineStream *SherpaOnnxCreateOnlineStream(
|
||||
const SherpaOnnxOnlineRecognizer *recognizer);
|
||||
@@ -523,6 +528,7 @@ SherpaOnnxCreateOnlineStreamWithHotwords(
|
||||
* SherpaOnnxDestroyOnlineStream(stream);
|
||||
* stream = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOnlineStream
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOnlineStream(
|
||||
const SherpaOnnxOnlineStream *stream);
|
||||
@@ -545,6 +551,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOnlineStream(
|
||||
* SherpaOnnxOnlineStreamAcceptWaveform(stream, wave->sample_rate,
|
||||
* wave->samples + start, chunk_size);
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOnlineStream, SherpaOnnxDecodeOnlineStream
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxOnlineStreamAcceptWaveform(
|
||||
const SherpaOnnxOnlineStream *stream, int32_t sample_rate,
|
||||
@@ -581,6 +588,7 @@ SherpaOnnxIsOnlineStreamReady(const SherpaOnnxOnlineRecognizer *recognizer,
|
||||
* SherpaOnnxDecodeOnlineStream(recognizer, stream);
|
||||
* }
|
||||
* @endcode
|
||||
* @see SherpaOnnxIsOnlineStreamReady, SherpaOnnxGetOnlineStreamResult
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDecodeOnlineStream(
|
||||
const SherpaOnnxOnlineRecognizer *recognizer,
|
||||
@@ -623,6 +631,7 @@ SHERPA_ONNX_API void SherpaOnnxDecodeMultipleOnlineStreams(
|
||||
* // are available.
|
||||
* SherpaOnnxDestroyOnlineRecognizerResult(r);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyOnlineRecognizerResult
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOnlineRecognizerResult *
|
||||
SherpaOnnxGetOnlineStreamResult(const SherpaOnnxOnlineRecognizer *recognizer,
|
||||
@@ -637,6 +646,7 @@ SherpaOnnxGetOnlineStreamResult(const SherpaOnnxOnlineRecognizer *recognizer,
|
||||
* SherpaOnnxDestroyOnlineRecognizerResult(r);
|
||||
* r = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxGetOnlineStreamResult
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOnlineRecognizerResult(
|
||||
const SherpaOnnxOnlineRecognizerResult *r);
|
||||
@@ -1151,6 +1161,7 @@ typedef struct SherpaOnnxOfflineModelConfig {
|
||||
* "./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/tokens.txt";
|
||||
* config.model_config.model_type = "nemo_transducer";
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOfflineRecognizer
|
||||
*/
|
||||
typedef struct SherpaOnnxOfflineRecognizerConfig {
|
||||
/** Feature extraction settings. */
|
||||
@@ -1242,6 +1253,7 @@ typedef struct SherpaOnnxOfflineStream SherpaOnnxOfflineStream;
|
||||
* "./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/tokens.txt";
|
||||
* config.model_config.model_type = "nemo_transducer";
|
||||
* @endcode
|
||||
* @see SherpaOnnxOfflineRecognizerConfig, SherpaOnnxDestroyOfflineRecognizer
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineRecognizer *
|
||||
SherpaOnnxCreateOfflineRecognizer(
|
||||
@@ -1270,6 +1282,7 @@ SHERPA_ONNX_API void SherpaOnnxOfflineRecognizerSetConfig(
|
||||
* SherpaOnnxDestroyOfflineRecognizer(recognizer);
|
||||
* recognizer = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOfflineRecognizer
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineRecognizer(
|
||||
const SherpaOnnxOfflineRecognizer *recognizer);
|
||||
@@ -1287,6 +1300,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOfflineRecognizer(
|
||||
* const SherpaOnnxOfflineStream *stream =
|
||||
* SherpaOnnxCreateOfflineStream(recognizer);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyOfflineStream, SherpaOnnxAcceptWaveformOffline
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineStream *SherpaOnnxCreateOfflineStream(
|
||||
const SherpaOnnxOfflineRecognizer *recognizer);
|
||||
@@ -1319,6 +1333,7 @@ SherpaOnnxCreateOfflineStreamWithHotwords(
|
||||
* SherpaOnnxDestroyOfflineStream(stream);
|
||||
* stream = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOfflineStream
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineStream(
|
||||
const SherpaOnnxOfflineStream *stream);
|
||||
@@ -1347,6 +1362,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOfflineStream(
|
||||
* wave->samples, wave->num_samples);
|
||||
* SherpaOnnxDecodeOfflineStream(recognizer, stream);
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOfflineStream, SherpaOnnxDecodeOfflineStream
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxAcceptWaveformOffline(
|
||||
const SherpaOnnxOfflineStream *stream, int32_t sample_rate,
|
||||
@@ -1408,6 +1424,7 @@ SHERPA_ONNX_API int32_t SherpaOnnxOfflineStreamHasOption(
|
||||
* @code
|
||||
* SherpaOnnxDecodeOfflineStream(recognizer, stream);
|
||||
* @endcode
|
||||
* @see SherpaOnnxAcceptWaveformOffline, SherpaOnnxGetOfflineStreamResult
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDecodeOfflineStream(
|
||||
const SherpaOnnxOfflineRecognizer *recognizer,
|
||||
@@ -1438,6 +1455,7 @@ SHERPA_ONNX_API void SherpaOnnxDecodeMultipleOfflineStreams(
|
||||
* All pointers in this struct are owned by the result object returned from
|
||||
* SherpaOnnxGetOfflineStreamResult() and become invalid after
|
||||
* SherpaOnnxDestroyOfflineRecognizerResult() is called.
|
||||
* @see SherpaOnnxGetOfflineStreamResult, SherpaOnnxDestroyOfflineRecognizerResult
|
||||
*/
|
||||
typedef struct SherpaOnnxOfflineRecognizerResult {
|
||||
/** Recognized text. */
|
||||
@@ -1520,6 +1538,7 @@ typedef struct SherpaOnnxOfflineRecognizerResult {
|
||||
* }
|
||||
* SherpaOnnxDestroyOfflineRecognizerResult(r);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyOfflineRecognizerResult, SherpaOnnxDecodeOfflineStream
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineRecognizerResult *
|
||||
SherpaOnnxGetOfflineStreamResult(const SherpaOnnxOfflineStream *stream);
|
||||
@@ -1533,6 +1552,7 @@ SherpaOnnxGetOfflineStreamResult(const SherpaOnnxOfflineStream *stream);
|
||||
* SherpaOnnxDestroyOfflineRecognizerResult(r);
|
||||
* r = NULL;
|
||||
* @endcode
|
||||
* @see SherpaOnnxGetOfflineStreamResult
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineRecognizerResult(
|
||||
const SherpaOnnxOfflineRecognizerResult *r);
|
||||
@@ -1573,6 +1593,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOfflineStreamResultJson(const char *s);
|
||||
* @brief Snapshot of the current keyword spotting result.
|
||||
*
|
||||
* Free this object with SherpaOnnxDestroyKeywordResult().
|
||||
* @see SherpaOnnxGetKeywordResult
|
||||
*/
|
||||
typedef struct SherpaOnnxKeywordResult {
|
||||
/**
|
||||
@@ -1658,6 +1679,7 @@ typedef struct SherpaOnnxKeywordResult {
|
||||
* config.keywords_score = 3.0f;
|
||||
* config.keywords_threshold = 0.1f;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateKeywordSpotter
|
||||
*/
|
||||
typedef struct SherpaOnnxKeywordSpotterConfig {
|
||||
/** Feature extraction parameters. */
|
||||
@@ -1690,6 +1712,7 @@ typedef struct SherpaOnnxKeywordSpotter SherpaOnnxKeywordSpotter;
|
||||
* @param config Keyword spotter configuration.
|
||||
* @return A newly allocated keyword spotter on success, or NULL on error. Free
|
||||
* it with SherpaOnnxDestroyKeywordSpotter().
|
||||
* @see SherpaOnnxKeywordSpotterConfig, SherpaOnnxDestroyKeywordSpotter
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxKeywordSpotter *SherpaOnnxCreateKeywordSpotter(
|
||||
const SherpaOnnxKeywordSpotterConfig *config);
|
||||
@@ -1698,6 +1721,7 @@ SHERPA_ONNX_API const SherpaOnnxKeywordSpotter *SherpaOnnxCreateKeywordSpotter(
|
||||
* @brief Destroy a keyword spotter.
|
||||
*
|
||||
* @param spotter A pointer returned by SherpaOnnxCreateKeywordSpotter().
|
||||
* @see SherpaOnnxCreateKeywordSpotter
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyKeywordSpotter(
|
||||
const SherpaOnnxKeywordSpotter *spotter);
|
||||
@@ -1807,6 +1831,7 @@ SHERPA_ONNX_API void SherpaOnnxDecodeMultipleKeywordStreams(
|
||||
* }
|
||||
* SherpaOnnxDestroyKeywordResult(r);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyKeywordResult
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxKeywordResult *SherpaOnnxGetKeywordResult(
|
||||
const SherpaOnnxKeywordSpotter *spotter,
|
||||
@@ -1816,6 +1841,7 @@ SHERPA_ONNX_API const SherpaOnnxKeywordResult *SherpaOnnxGetKeywordResult(
|
||||
* @brief Destroy a keyword result snapshot.
|
||||
*
|
||||
* @param r A pointer returned by SherpaOnnxGetKeywordResult().
|
||||
* @see SherpaOnnxGetKeywordResult
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyKeywordResult(
|
||||
const SherpaOnnxKeywordResult *r);
|
||||
@@ -1916,6 +1942,7 @@ typedef struct SherpaOnnxTenVadModelConfig {
|
||||
* config.provider = "cpu";
|
||||
* config.debug = 0;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateVoiceActivityDetector
|
||||
*/
|
||||
typedef struct SherpaOnnxVadModelConfig {
|
||||
/** Silero VAD configuration. */
|
||||
@@ -2040,6 +2067,7 @@ SHERPA_ONNX_API void SherpaOnnxCircularBufferReset(
|
||||
*
|
||||
* The segment owns @c samples. Free the whole object with
|
||||
* SherpaOnnxDestroySpeechSegment().
|
||||
* @see SherpaOnnxVoiceActivityDetectorFront, SherpaOnnxDestroySpeechSegment
|
||||
*/
|
||||
typedef struct SherpaOnnxSpeechSegment {
|
||||
/** Start index, in input samples, of this segment. */
|
||||
@@ -2078,6 +2106,7 @@ typedef struct SherpaOnnxVoiceActivityDetector SherpaOnnxVoiceActivityDetector;
|
||||
* const SherpaOnnxVoiceActivityDetector *vad =
|
||||
* SherpaOnnxCreateVoiceActivityDetector(&config, 30.0f);
|
||||
* @endcode
|
||||
* @see SherpaOnnxVadModelConfig, SherpaOnnxDestroyVoiceActivityDetector
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxVoiceActivityDetector *
|
||||
SherpaOnnxCreateVoiceActivityDetector(const SherpaOnnxVadModelConfig *config,
|
||||
@@ -2087,6 +2116,7 @@ SherpaOnnxCreateVoiceActivityDetector(const SherpaOnnxVadModelConfig *config,
|
||||
* @brief Destroy a voice activity detector.
|
||||
*
|
||||
* @param p A pointer returned by SherpaOnnxCreateVoiceActivityDetector().
|
||||
* @see SherpaOnnxCreateVoiceActivityDetector
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyVoiceActivityDetector(
|
||||
const SherpaOnnxVoiceActivityDetector *p);
|
||||
@@ -2172,6 +2202,7 @@ SHERPA_ONNX_API void SherpaOnnxVoiceActivityDetectorClear(
|
||||
* SherpaOnnxVoiceActivityDetectorPop(vad);
|
||||
* }
|
||||
* @endcode
|
||||
* @see SherpaOnnxSpeechSegment, SherpaOnnxDestroySpeechSegment
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxSpeechSegment *
|
||||
SherpaOnnxVoiceActivityDetectorFront(const SherpaOnnxVoiceActivityDetector *p);
|
||||
@@ -2181,6 +2212,7 @@ SherpaOnnxVoiceActivityDetectorFront(const SherpaOnnxVoiceActivityDetector *p);
|
||||
* SherpaOnnxVoiceActivityDetectorFront().
|
||||
*
|
||||
* @param p A pointer returned by SherpaOnnxVoiceActivityDetectorFront().
|
||||
* @see SherpaOnnxVoiceActivityDetectorFront
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroySpeechSegment(
|
||||
const SherpaOnnxSpeechSegment *p);
|
||||
@@ -2403,6 +2435,7 @@ typedef struct SherpaOnnxOfflineTtsModelConfig {
|
||||
* config.model.debug = 0;
|
||||
* config.max_num_sentences = 2;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateOfflineTts
|
||||
*/
|
||||
typedef struct SherpaOnnxOfflineTtsConfig {
|
||||
/** TTS model configuration. */
|
||||
@@ -2422,6 +2455,7 @@ typedef struct SherpaOnnxOfflineTtsConfig {
|
||||
*
|
||||
* The returned structure owns @c samples. Free the whole object with
|
||||
* SherpaOnnxDestroyOfflineTtsGeneratedAudio().
|
||||
* @see SherpaOnnxOfflineTtsGenerateWithConfig, SherpaOnnxDestroyOfflineTtsGeneratedAudio
|
||||
*/
|
||||
typedef struct SherpaOnnxGeneratedAudio {
|
||||
/** Generated mono samples in the range [-1, 1]. */
|
||||
@@ -2490,6 +2524,7 @@ typedef struct SherpaOnnxOfflineTts SherpaOnnxOfflineTts;
|
||||
*
|
||||
* const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
* @endcode
|
||||
* @see SherpaOnnxOfflineTtsConfig, SherpaOnnxDestroyOfflineTts
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineTts *SherpaOnnxCreateOfflineTts(
|
||||
const SherpaOnnxOfflineTtsConfig *config);
|
||||
@@ -2498,6 +2533,7 @@ SHERPA_ONNX_API const SherpaOnnxOfflineTts *SherpaOnnxCreateOfflineTts(
|
||||
* @brief Destroy an offline TTS engine.
|
||||
*
|
||||
* @param tts A pointer returned by SherpaOnnxCreateOfflineTts().
|
||||
* @see SherpaOnnxCreateOfflineTts
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineTts(
|
||||
const SherpaOnnxOfflineTts *tts);
|
||||
@@ -2541,6 +2577,7 @@ SherpaOnnxOfflineTtsNumSpeakers(const SherpaOnnxOfflineTts *tts);
|
||||
* "./generated.wav");
|
||||
* SherpaOnnxDestroyOfflineTtsGeneratedAudio(audio);
|
||||
* @endcode
|
||||
* @see SherpaOnnxDestroyOfflineTtsGeneratedAudio, SherpaOnnxGenerationConfig
|
||||
*/
|
||||
SHERPA_ONNX_API SHERPA_ONNX_DEPRECATED(
|
||||
"Use SherpaOnnxOfflineTtsGenerateWithConfig() instead") const
|
||||
@@ -2675,6 +2712,7 @@ SHERPA_ONNX_API SHERPA_ONNX_DEPRECATED(
|
||||
* cfg.reference_sample_rate = wave->sample_rate;
|
||||
* cfg.extra = "{\"max_reference_audio_len\": 10.0, \"seed\": 42}";
|
||||
* @endcode
|
||||
* @see SherpaOnnxOfflineTtsGenerateWithConfig
|
||||
*/
|
||||
typedef struct SherpaOnnxGenerationConfig {
|
||||
/** Silence scale between sentences. */
|
||||
@@ -2736,6 +2774,7 @@ SherpaOnnxOfflineTtsGenerateWithConfig(
|
||||
*
|
||||
* @param p A pointer returned by one of the SherpaOnnxOfflineTtsGenerate*
|
||||
* functions.
|
||||
* @see SherpaOnnxOfflineTtsGenerateWithConfig
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineTtsGeneratedAudio(
|
||||
const SherpaOnnxGeneratedAudio *p);
|
||||
@@ -2753,6 +2792,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOfflineTtsGeneratedAudio(
|
||||
* SherpaOnnxWriteWave(audio->samples, audio->n, audio->sample_rate,
|
||||
* "./generated-kokoro-en.wav");
|
||||
* @endcode
|
||||
* @see SherpaOnnxReadWave
|
||||
*/
|
||||
SHERPA_ONNX_API int32_t SherpaOnnxWriteWave(const float *samples, int32_t n,
|
||||
int32_t sample_rate,
|
||||
@@ -2798,6 +2838,7 @@ SHERPA_ONNX_API int32_t SherpaOnnxWriteWaveMultiChannel(
|
||||
* @brief Decoded mono WAVE file content.
|
||||
*
|
||||
* Free this object with SherpaOnnxFreeWave().
|
||||
* @see SherpaOnnxReadWave, SherpaOnnxFreeWave
|
||||
*/
|
||||
typedef struct SherpaOnnxWave {
|
||||
/** Samples normalized to the range [-1, 1]. */
|
||||
@@ -2823,6 +2864,7 @@ typedef struct SherpaOnnxWave {
|
||||
* SherpaOnnxFreeWave(wave);
|
||||
* }
|
||||
* @endcode
|
||||
* @see SherpaOnnxFreeWave, SherpaOnnxWave
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxWave *SherpaOnnxReadWave(const char *filename);
|
||||
|
||||
@@ -2840,6 +2882,7 @@ SHERPA_ONNX_API const SherpaOnnxWave *SherpaOnnxReadWaveFromBinaryData(
|
||||
/**
|
||||
* @brief Destroy a wave object returned by SherpaOnnxReadWave() or
|
||||
* SherpaOnnxReadWaveFromBinaryData().
|
||||
* @see SherpaOnnxReadWave
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxFreeWave(const SherpaOnnxWave *wave);
|
||||
|
||||
@@ -2942,6 +2985,7 @@ typedef struct SherpaOnnxSpokenLanguageIdentification
|
||||
* @param config Spoken-language identification configuration.
|
||||
* @return A newly allocated identifier on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroySpokenLanguageIdentification().
|
||||
* @see SherpaOnnxDestroySpokenLanguageIdentification
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxSpokenLanguageIdentification *
|
||||
SherpaOnnxCreateSpokenLanguageIdentification(
|
||||
@@ -2952,6 +2996,7 @@ SherpaOnnxCreateSpokenLanguageIdentification(
|
||||
*
|
||||
* @param slid A pointer returned by
|
||||
* SherpaOnnxCreateSpokenLanguageIdentification().
|
||||
* @see SherpaOnnxCreateSpokenLanguageIdentification
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroySpokenLanguageIdentification(
|
||||
const SherpaOnnxSpokenLanguageIdentification *slid);
|
||||
@@ -3037,6 +3082,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroySpokenLanguageIdentificationResult(
|
||||
* config.num_threads = 1;
|
||||
* config.provider = "cpu";
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateSpeakerEmbeddingExtractor
|
||||
*/
|
||||
typedef struct SherpaOnnxSpeakerEmbeddingExtractorConfig {
|
||||
/** Speaker embedding model file. */
|
||||
@@ -3059,6 +3105,7 @@ typedef struct SherpaOnnxSpeakerEmbeddingExtractor
|
||||
* @param config Speaker embedding extractor configuration.
|
||||
* @return A newly allocated extractor on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroySpeakerEmbeddingExtractor().
|
||||
* @see SherpaOnnxSpeakerEmbeddingExtractorConfig, SherpaOnnxDestroySpeakerEmbeddingExtractor
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxSpeakerEmbeddingExtractor *
|
||||
SherpaOnnxCreateSpeakerEmbeddingExtractor(
|
||||
@@ -3068,6 +3115,7 @@ SherpaOnnxCreateSpeakerEmbeddingExtractor(
|
||||
* @brief Destroy a speaker embedding extractor.
|
||||
*
|
||||
* @param p A pointer returned by SherpaOnnxCreateSpeakerEmbeddingExtractor().
|
||||
* @see SherpaOnnxCreateSpeakerEmbeddingExtractor
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroySpeakerEmbeddingExtractor(
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *p);
|
||||
@@ -3148,7 +3196,11 @@ SherpaOnnxSpeakerEmbeddingExtractorComputeEmbedding(
|
||||
SHERPA_ONNX_API void SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(
|
||||
const float *v);
|
||||
|
||||
/** @brief Opaque speaker embedding manager handle. */
|
||||
/**
|
||||
* @brief Opaque speaker embedding manager handle.
|
||||
*
|
||||
* @see SherpaOnnxCreateSpeakerEmbeddingManager
|
||||
*/
|
||||
typedef struct SherpaOnnxSpeakerEmbeddingManager
|
||||
SherpaOnnxSpeakerEmbeddingManager;
|
||||
|
||||
@@ -3162,6 +3214,7 @@ typedef struct SherpaOnnxSpeakerEmbeddingManager
|
||||
* SherpaOnnxSpeakerEmbeddingExtractorDim().
|
||||
* @return A newly allocated manager. Free it with
|
||||
* SherpaOnnxDestroySpeakerEmbeddingManager().
|
||||
* @see SherpaOnnxDestroySpeakerEmbeddingManager
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxSpeakerEmbeddingManager *
|
||||
SherpaOnnxCreateSpeakerEmbeddingManager(int32_t dim);
|
||||
@@ -3170,6 +3223,7 @@ SherpaOnnxCreateSpeakerEmbeddingManager(int32_t dim);
|
||||
* @brief Destroy a speaker embedding manager.
|
||||
*
|
||||
* @param p A pointer returned by SherpaOnnxCreateSpeakerEmbeddingManager().
|
||||
* @see SherpaOnnxCreateSpeakerEmbeddingManager
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroySpeakerEmbeddingManager(
|
||||
const SherpaOnnxSpeakerEmbeddingManager *p);
|
||||
@@ -3411,6 +3465,7 @@ typedef struct SherpaOnnxAudioTaggingModelConfig {
|
||||
* "./sherpa-onnx-zipformer-audio-tagging-2024-04-09/class_labels_indices.csv";
|
||||
* config.top_k = 5;
|
||||
* @endcode
|
||||
* @see SherpaOnnxCreateAudioTagging
|
||||
*/
|
||||
typedef struct SherpaOnnxAudioTaggingConfig {
|
||||
/** Acoustic model configuration. */
|
||||
@@ -3443,6 +3498,7 @@ typedef struct SherpaOnnxAudioTagging SherpaOnnxAudioTagging;
|
||||
* @param config Audio-tagging configuration.
|
||||
* @return A newly allocated audio tagger on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroyAudioTagging().
|
||||
* @see SherpaOnnxAudioTaggingConfig, SherpaOnnxDestroyAudioTagging
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxAudioTagging *SherpaOnnxCreateAudioTagging(
|
||||
const SherpaOnnxAudioTaggingConfig *config);
|
||||
@@ -3451,6 +3507,7 @@ SHERPA_ONNX_API const SherpaOnnxAudioTagging *SherpaOnnxCreateAudioTagging(
|
||||
* @brief Destroy an audio tagger.
|
||||
*
|
||||
* @param tagger A pointer returned by SherpaOnnxCreateAudioTagging().
|
||||
* @see SherpaOnnxCreateAudioTagging
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyAudioTagging(
|
||||
const SherpaOnnxAudioTagging *tagger);
|
||||
@@ -3545,6 +3602,7 @@ typedef struct SherpaOnnxOfflinePunctuation SherpaOnnxOfflinePunctuation;
|
||||
* @param config Offline punctuation configuration.
|
||||
* @return A newly allocated punctuation processor on success, or NULL on
|
||||
* error. Free it with SherpaOnnxDestroyOfflinePunctuation().
|
||||
* @see SherpaOnnxDestroyOfflinePunctuation, SherpaOfflinePunctuationAddPunct
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflinePunctuation *
|
||||
SherpaOnnxCreateOfflinePunctuation(
|
||||
@@ -3554,6 +3612,7 @@ SherpaOnnxCreateOfflinePunctuation(
|
||||
* @brief Destroy an offline punctuation processor.
|
||||
*
|
||||
* @param punct A pointer returned by SherpaOnnxCreateOfflinePunctuation().
|
||||
* @see SherpaOnnxCreateOfflinePunctuation
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflinePunctuation(
|
||||
const SherpaOnnxOfflinePunctuation *punct);
|
||||
@@ -3565,6 +3624,7 @@ SHERPA_ONNX_API void SherpaOnnxDestroyOfflinePunctuation(
|
||||
* @param text Input text without punctuation.
|
||||
* @return A newly allocated punctuated string. Free it with
|
||||
* SherpaOfflinePunctuationFreeText().
|
||||
* @see SherpaOfflinePunctuationFreeText
|
||||
*/
|
||||
SHERPA_ONNX_API const char *SherpaOfflinePunctuationAddPunct(
|
||||
const SherpaOnnxOfflinePunctuation *punct, const char *text);
|
||||
@@ -3573,6 +3633,7 @@ SHERPA_ONNX_API const char *SherpaOfflinePunctuationAddPunct(
|
||||
* @brief Free a string returned by SherpaOfflinePunctuationAddPunct().
|
||||
*
|
||||
* @param text A pointer returned by SherpaOfflinePunctuationAddPunct().
|
||||
* @see SherpaOfflinePunctuationAddPunct
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOfflinePunctuationFreeText(const char *text);
|
||||
|
||||
@@ -3837,6 +3898,7 @@ typedef struct SherpaOnnxOfflineSpeakerDiarization
|
||||
* @param config Offline speaker diarization configuration.
|
||||
* @return A newly allocated diarizer on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroyOfflineSpeakerDiarization().
|
||||
* @see SherpaOnnxDestroyOfflineSpeakerDiarization
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineSpeakerDiarization *
|
||||
SherpaOnnxCreateOfflineSpeakerDiarization(
|
||||
@@ -3846,6 +3908,7 @@ SherpaOnnxCreateOfflineSpeakerDiarization(
|
||||
* @brief Destroy an offline speaker diarizer.
|
||||
*
|
||||
* @param sd A pointer returned by SherpaOnnxCreateOfflineSpeakerDiarization().
|
||||
* @see SherpaOnnxCreateOfflineSpeakerDiarization
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineSpeakerDiarization(
|
||||
const SherpaOnnxOfflineSpeakerDiarization *sd);
|
||||
@@ -4069,6 +4132,7 @@ typedef struct SherpaOnnxOfflineSpeechDenoiser SherpaOnnxOfflineSpeechDenoiser;
|
||||
* @param config Offline denoiser configuration.
|
||||
* @return A newly allocated denoiser on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroyOfflineSpeechDenoiser().
|
||||
* @see SherpaOnnxDestroyOfflineSpeechDenoiser
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineSpeechDenoiser *
|
||||
SherpaOnnxCreateOfflineSpeechDenoiser(
|
||||
@@ -4078,6 +4142,7 @@ SherpaOnnxCreateOfflineSpeechDenoiser(
|
||||
* @brief Destroy an offline speech denoiser.
|
||||
*
|
||||
* @param sd A pointer returned by SherpaOnnxCreateOfflineSpeechDenoiser().
|
||||
* @see SherpaOnnxCreateOfflineSpeechDenoiser
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineSpeechDenoiser(
|
||||
const SherpaOnnxOfflineSpeechDenoiser *sd);
|
||||
@@ -4157,6 +4222,7 @@ typedef struct SherpaOnnxOnlineSpeechDenoiser SherpaOnnxOnlineSpeechDenoiser;
|
||||
* @param config Online denoiser configuration.
|
||||
* @return A newly allocated denoiser on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroyOnlineSpeechDenoiser().
|
||||
* @see SherpaOnnxDestroyOnlineSpeechDenoiser
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOnlineSpeechDenoiser *
|
||||
SherpaOnnxCreateOnlineSpeechDenoiser(
|
||||
@@ -4166,6 +4232,7 @@ SherpaOnnxCreateOnlineSpeechDenoiser(
|
||||
* @brief Destroy an online speech denoiser.
|
||||
*
|
||||
* @param sd A pointer returned by SherpaOnnxCreateOnlineSpeechDenoiser().
|
||||
* @see SherpaOnnxCreateOnlineSpeechDenoiser
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOnlineSpeechDenoiser(
|
||||
const SherpaOnnxOnlineSpeechDenoiser *sd);
|
||||
@@ -4270,6 +4337,7 @@ typedef struct SherpaOnnxOfflineSourceSeparation
|
||||
* @param config Source-separation configuration.
|
||||
* @return A newly allocated engine on success, or NULL on error. Free it
|
||||
* with SherpaOnnxDestroyOfflineSourceSeparation().
|
||||
* @see SherpaOnnxDestroyOfflineSourceSeparation
|
||||
*/
|
||||
SHERPA_ONNX_API const SherpaOnnxOfflineSourceSeparation *
|
||||
SherpaOnnxCreateOfflineSourceSeparation(
|
||||
@@ -4279,6 +4347,7 @@ SherpaOnnxCreateOfflineSourceSeparation(
|
||||
* @brief Destroy a source-separation engine.
|
||||
*
|
||||
* @param ss A pointer returned by SherpaOnnxCreateOfflineSourceSeparation().
|
||||
* @see SherpaOnnxCreateOfflineSourceSeparation
|
||||
*/
|
||||
SHERPA_ONNX_API void SherpaOnnxDestroyOfflineSourceSeparation(
|
||||
const SherpaOnnxOfflineSourceSeparation *ss);
|
||||
|
||||
@@ -1246,4 +1246,310 @@ int32_t OfflineSourceSeparation::GetNumberOfStems() const {
|
||||
return SherpaOnnxOfflineSourceSeparationGetNumberOfStems(p_);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Spoken Language Identification
|
||||
// ============================================================================
|
||||
|
||||
SpokenLanguageIdentification SpokenLanguageIdentification::Create(
|
||||
const SpokenLanguageIdentificationConfig &config) {
|
||||
struct SherpaOnnxSpokenLanguageIdentificationConfig c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.whisper.encoder = config.whisper.encoder.c_str();
|
||||
c.whisper.decoder = config.whisper.decoder.c_str();
|
||||
c.whisper.tail_paddings = config.whisper.tail_paddings;
|
||||
c.num_threads = config.num_threads;
|
||||
c.debug = config.debug;
|
||||
c.provider = config.provider.c_str();
|
||||
|
||||
const SherpaOnnxSpokenLanguageIdentification *p =
|
||||
SherpaOnnxCreateSpokenLanguageIdentification(&c);
|
||||
return SpokenLanguageIdentification(p);
|
||||
}
|
||||
|
||||
SpokenLanguageIdentification::SpokenLanguageIdentification(
|
||||
const SherpaOnnxSpokenLanguageIdentification *p)
|
||||
: MoveOnly<SpokenLanguageIdentification,
|
||||
SherpaOnnxSpokenLanguageIdentification>(p) {}
|
||||
|
||||
void SpokenLanguageIdentification::Destroy(
|
||||
const SherpaOnnxSpokenLanguageIdentification *p) const {
|
||||
SherpaOnnxDestroySpokenLanguageIdentification(p);
|
||||
}
|
||||
|
||||
OfflineStream SpokenLanguageIdentification::CreateStream() const {
|
||||
const SherpaOnnxOfflineStream *s =
|
||||
SherpaOnnxSpokenLanguageIdentificationCreateOfflineStream(p_);
|
||||
return OfflineStream(s);
|
||||
}
|
||||
|
||||
SpokenLanguageIdentificationResult SpokenLanguageIdentification::Compute(
|
||||
const OfflineStream *s) const {
|
||||
const SherpaOnnxSpokenLanguageIdentificationResult *r =
|
||||
SherpaOnnxSpokenLanguageIdentificationCompute(p_, s->Get());
|
||||
SpokenLanguageIdentificationResult ans;
|
||||
if (r && r->lang) {
|
||||
ans.lang = r->lang;
|
||||
}
|
||||
SherpaOnnxDestroySpokenLanguageIdentificationResult(r);
|
||||
return ans;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Speaker Embedding Extractor
|
||||
// ============================================================================
|
||||
|
||||
SpeakerEmbeddingExtractor SpeakerEmbeddingExtractor::Create(
|
||||
const SpeakerEmbeddingExtractorConfig &config) {
|
||||
struct SherpaOnnxSpeakerEmbeddingExtractorConfig c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.model = config.model.c_str();
|
||||
c.num_threads = config.num_threads;
|
||||
c.debug = config.debug;
|
||||
c.provider = config.provider.c_str();
|
||||
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *p =
|
||||
SherpaOnnxCreateSpeakerEmbeddingExtractor(&c);
|
||||
return SpeakerEmbeddingExtractor(p);
|
||||
}
|
||||
|
||||
SpeakerEmbeddingExtractor::SpeakerEmbeddingExtractor(
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *p)
|
||||
: MoveOnly<SpeakerEmbeddingExtractor,
|
||||
SherpaOnnxSpeakerEmbeddingExtractor>(p) {}
|
||||
|
||||
void SpeakerEmbeddingExtractor::Destroy(
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *p) const {
|
||||
SherpaOnnxDestroySpeakerEmbeddingExtractor(p);
|
||||
}
|
||||
|
||||
int32_t SpeakerEmbeddingExtractor::Dim() const {
|
||||
return SherpaOnnxSpeakerEmbeddingExtractorDim(p_);
|
||||
}
|
||||
|
||||
OnlineStream SpeakerEmbeddingExtractor::CreateStream() const {
|
||||
const SherpaOnnxOnlineStream *s =
|
||||
SherpaOnnxSpeakerEmbeddingExtractorCreateStream(p_);
|
||||
return OnlineStream(s);
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingExtractor::IsReady(const OnlineStream *s) const {
|
||||
return SherpaOnnxSpeakerEmbeddingExtractorIsReady(p_, s->Get()) != 0;
|
||||
}
|
||||
|
||||
std::vector<float> SpeakerEmbeddingExtractor::ComputeEmbedding(
|
||||
const OnlineStream *s) const {
|
||||
const float *v =
|
||||
SherpaOnnxSpeakerEmbeddingExtractorComputeEmbedding(p_, s->Get());
|
||||
if (!v) return {};
|
||||
int32_t dim = Dim();
|
||||
std::vector<float> ans(v, v + dim);
|
||||
SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(v);
|
||||
return ans;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Speaker Embedding Manager
|
||||
// ============================================================================
|
||||
|
||||
SpeakerEmbeddingManager SpeakerEmbeddingManager::Create(int32_t dim) {
|
||||
const SherpaOnnxSpeakerEmbeddingManager *p =
|
||||
SherpaOnnxCreateSpeakerEmbeddingManager(dim);
|
||||
return SpeakerEmbeddingManager(p);
|
||||
}
|
||||
|
||||
SpeakerEmbeddingManager::SpeakerEmbeddingManager(
|
||||
const SherpaOnnxSpeakerEmbeddingManager *p)
|
||||
: MoveOnly<SpeakerEmbeddingManager, SherpaOnnxSpeakerEmbeddingManager>(p) {}
|
||||
|
||||
void SpeakerEmbeddingManager::Destroy(
|
||||
const SherpaOnnxSpeakerEmbeddingManager *p) const {
|
||||
SherpaOnnxDestroySpeakerEmbeddingManager(p);
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::Add(const std::string &name,
|
||||
const float *v) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerAdd(p_, name.c_str(), v) != 0;
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::AddList(const std::string &name,
|
||||
const float **v) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerAddList(p_, name.c_str(), v) != 0;
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::AddListFlattened(const std::string &name,
|
||||
const float *v,
|
||||
int32_t n) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerAddListFlattened(p_, name.c_str(), v,
|
||||
n) != 0;
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::Remove(const std::string &name) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerRemove(p_, name.c_str()) != 0;
|
||||
}
|
||||
|
||||
std::string SpeakerEmbeddingManager::Search(const float *v,
|
||||
float threshold) const {
|
||||
const char *name =
|
||||
SherpaOnnxSpeakerEmbeddingManagerSearch(p_, v, threshold);
|
||||
if (!name) return {};
|
||||
std::string ans(name);
|
||||
SherpaOnnxSpeakerEmbeddingManagerFreeSearch(name);
|
||||
return ans;
|
||||
}
|
||||
|
||||
std::vector<SpeakerMatch> SpeakerEmbeddingManager::GetBestMatches(
|
||||
const float *v, float threshold, int32_t n) const {
|
||||
const SherpaOnnxSpeakerEmbeddingManagerBestMatchesResult *r =
|
||||
SherpaOnnxSpeakerEmbeddingManagerGetBestMatches(p_, v, threshold, n);
|
||||
std::vector<SpeakerMatch> ans;
|
||||
if (r) {
|
||||
for (int32_t i = 0; i < r->count; ++i) {
|
||||
SpeakerMatch m;
|
||||
m.score = r->matches[i].score;
|
||||
if (r->matches[i].name) m.name = r->matches[i].name;
|
||||
ans.push_back(std::move(m));
|
||||
}
|
||||
SherpaOnnxSpeakerEmbeddingManagerFreeBestMatches(r);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::Verify(const std::string &name, const float *v,
|
||||
float threshold) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerVerify(p_, name.c_str(), v,
|
||||
threshold) != 0;
|
||||
}
|
||||
|
||||
bool SpeakerEmbeddingManager::Contains(const std::string &name) const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerContains(p_, name.c_str()) != 0;
|
||||
}
|
||||
|
||||
int32_t SpeakerEmbeddingManager::NumSpeakers() const {
|
||||
return SherpaOnnxSpeakerEmbeddingManagerNumSpeakers(p_);
|
||||
}
|
||||
|
||||
std::vector<std::string> SpeakerEmbeddingManager::GetAllSpeakers() const {
|
||||
const char *const *names =
|
||||
SherpaOnnxSpeakerEmbeddingManagerGetAllSpeakers(p_);
|
||||
std::vector<std::string> ans;
|
||||
if (names) {
|
||||
for (int32_t i = 0; names[i]; ++i) {
|
||||
ans.emplace_back(names[i]);
|
||||
}
|
||||
SherpaOnnxSpeakerEmbeddingManagerFreeAllSpeakers(names);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Offline Speaker Diarization
|
||||
// ============================================================================
|
||||
|
||||
static int32_t DiarizationProgressCallback(int32_t num_processed_chunks,
|
||||
int32_t num_total_chunks,
|
||||
void *arg) {
|
||||
auto *cb = static_cast<OfflineSpeakerDiarizationProgressCallback *>(arg);
|
||||
(*cb)(num_processed_chunks, num_total_chunks);
|
||||
return 0;
|
||||
}
|
||||
|
||||
OfflineSpeakerDiarization OfflineSpeakerDiarization::Create(
|
||||
const OfflineSpeakerDiarizationConfig &config) {
|
||||
struct SherpaOnnxOfflineSpeakerDiarizationConfig c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.segmentation.pyannote.model =
|
||||
config.segmentation.pyannote.model.c_str();
|
||||
c.segmentation.num_threads = config.segmentation.num_threads;
|
||||
c.segmentation.debug = config.segmentation.debug;
|
||||
c.segmentation.provider = config.segmentation.provider.c_str();
|
||||
c.embedding.model = config.embedding.model.c_str();
|
||||
c.embedding.num_threads = config.embedding.num_threads;
|
||||
c.embedding.debug = config.embedding.debug;
|
||||
c.embedding.provider = config.embedding.provider.c_str();
|
||||
c.clustering.num_clusters = config.clustering.num_clusters;
|
||||
c.clustering.threshold = config.clustering.threshold;
|
||||
c.min_duration_on = config.min_duration_on;
|
||||
c.min_duration_off = config.min_duration_off;
|
||||
|
||||
const SherpaOnnxOfflineSpeakerDiarization *p =
|
||||
SherpaOnnxCreateOfflineSpeakerDiarization(&c);
|
||||
return OfflineSpeakerDiarization(p);
|
||||
}
|
||||
|
||||
OfflineSpeakerDiarization::OfflineSpeakerDiarization(
|
||||
const SherpaOnnxOfflineSpeakerDiarization *p)
|
||||
: MoveOnly<OfflineSpeakerDiarization,
|
||||
SherpaOnnxOfflineSpeakerDiarization>(p) {}
|
||||
|
||||
void OfflineSpeakerDiarization::Destroy(
|
||||
const SherpaOnnxOfflineSpeakerDiarization *p) const {
|
||||
SherpaOnnxDestroyOfflineSpeakerDiarization(p);
|
||||
}
|
||||
|
||||
int32_t OfflineSpeakerDiarization::GetSampleRate() const {
|
||||
return SherpaOnnxOfflineSpeakerDiarizationGetSampleRate(p_);
|
||||
}
|
||||
|
||||
void OfflineSpeakerDiarization::SetConfig(
|
||||
const OfflineSpeakerDiarizationConfig &config) const {
|
||||
struct SherpaOnnxOfflineSpeakerDiarizationConfig c;
|
||||
memset(&c, 0, sizeof(c));
|
||||
c.clustering.num_clusters = config.clustering.num_clusters;
|
||||
c.clustering.threshold = config.clustering.threshold;
|
||||
SherpaOnnxOfflineSpeakerDiarizationSetConfig(p_, &c);
|
||||
}
|
||||
|
||||
std::vector<OfflineSpeakerDiarizationSegment>
|
||||
OfflineSpeakerDiarization::Process(const float *samples, int32_t n) const {
|
||||
const SherpaOnnxOfflineSpeakerDiarizationResult *r =
|
||||
SherpaOnnxOfflineSpeakerDiarizationProcess(p_, samples, n);
|
||||
std::vector<OfflineSpeakerDiarizationSegment> ans;
|
||||
if (r) {
|
||||
int32_t num_segments =
|
||||
SherpaOnnxOfflineSpeakerDiarizationResultGetNumSegments(r);
|
||||
const SherpaOnnxOfflineSpeakerDiarizationSegment *segments =
|
||||
SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime(r);
|
||||
for (int32_t i = 0; i < num_segments; ++i) {
|
||||
OfflineSpeakerDiarizationSegment seg;
|
||||
seg.start = segments[i].start;
|
||||
seg.end = segments[i].end;
|
||||
seg.speaker = segments[i].speaker;
|
||||
ans.push_back(seg);
|
||||
}
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroySegment(segments);
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroyResult(r);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
std::vector<OfflineSpeakerDiarizationSegment>
|
||||
OfflineSpeakerDiarization::Process(
|
||||
const float *samples, int32_t n,
|
||||
const OfflineSpeakerDiarizationProgressCallback &callback) const {
|
||||
if (!callback) {
|
||||
return Process(samples, n);
|
||||
}
|
||||
OfflineSpeakerDiarizationProgressCallback cb = callback;
|
||||
const SherpaOnnxOfflineSpeakerDiarizationResult *r =
|
||||
SherpaOnnxOfflineSpeakerDiarizationProcessWithCallback(
|
||||
p_, samples, n, DiarizationProgressCallback, &cb);
|
||||
std::vector<OfflineSpeakerDiarizationSegment> ans;
|
||||
if (r) {
|
||||
int32_t num_segments =
|
||||
SherpaOnnxOfflineSpeakerDiarizationResultGetNumSegments(r);
|
||||
const SherpaOnnxOfflineSpeakerDiarizationSegment *segments =
|
||||
SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime(r);
|
||||
for (int32_t i = 0; i < num_segments; ++i) {
|
||||
OfflineSpeakerDiarizationSegment seg;
|
||||
seg.start = segments[i].start;
|
||||
seg.end = segments[i].end;
|
||||
seg.speaker = segments[i].speaker;
|
||||
ans.push_back(seg);
|
||||
}
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroySegment(segments);
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroyResult(r);
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
} // namespace sherpa_onnx::cxx
|
||||
@@ -44,6 +44,7 @@
|
||||
#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>
|
||||
@@ -1740,6 +1741,256 @@ class SHERPA_ONNX_API OfflineSourceSeparation
|
||||
explicit OfflineSourceSeparation(const SherpaOnnxOfflineSourceSeparation *p);
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// Spoken Language Identification
|
||||
// ============================================================================
|
||||
|
||||
/** @brief Whisper model configuration for spoken language identification. */
|
||||
struct SpokenLanguageIdentificationWhisperConfig {
|
||||
/** Whisper encoder model. */
|
||||
std::string encoder;
|
||||
/** Whisper decoder model. */
|
||||
std::string decoder;
|
||||
/** Optional tail padding in samples. */
|
||||
int32_t tail_paddings = 0;
|
||||
};
|
||||
|
||||
/** @brief Configuration for spoken language identification. */
|
||||
struct SpokenLanguageIdentificationConfig {
|
||||
/** Whisper model configuration. */
|
||||
SpokenLanguageIdentificationWhisperConfig whisper;
|
||||
/** Number of inference threads. */
|
||||
int32_t num_threads = 1;
|
||||
/** Enable verbose debug logging. */
|
||||
bool debug = false;
|
||||
/** Execution provider such as `"cpu"`. */
|
||||
std::string provider = "cpu";
|
||||
};
|
||||
|
||||
/** @brief Result of spoken language identification. */
|
||||
struct SpokenLanguageIdentificationResult {
|
||||
/** Predicted language code such as `"en"`, `"de"`, `"zh"`, or `"es"`. */
|
||||
std::string lang;
|
||||
};
|
||||
|
||||
/** @brief RAII wrapper for spoken language identification. */
|
||||
class SHERPA_ONNX_API SpokenLanguageIdentification
|
||||
: public MoveOnly<SpokenLanguageIdentification,
|
||||
SherpaOnnxSpokenLanguageIdentification> {
|
||||
public:
|
||||
/** @brief Create a spoken language identifier. */
|
||||
static SpokenLanguageIdentification Create(
|
||||
const SpokenLanguageIdentificationConfig &config);
|
||||
|
||||
/** @brief Destroy the wrapped C handle. */
|
||||
void Destroy(const SherpaOnnxSpokenLanguageIdentification *p) const;
|
||||
|
||||
/** @brief Create an offline stream for identification. */
|
||||
OfflineStream CreateStream() const;
|
||||
|
||||
/** @brief Run spoken language identification on a stream. */
|
||||
SpokenLanguageIdentificationResult Compute(const OfflineStream *s) const;
|
||||
|
||||
private:
|
||||
explicit SpokenLanguageIdentification(
|
||||
const SherpaOnnxSpokenLanguageIdentification *p);
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// Speaker Embedding Extractor
|
||||
// ============================================================================
|
||||
|
||||
/** @brief Configuration for speaker embedding extraction. */
|
||||
struct SpeakerEmbeddingExtractorConfig {
|
||||
/** Speaker embedding model file. */
|
||||
std::string model;
|
||||
/** Number of inference threads. */
|
||||
int32_t num_threads = 1;
|
||||
/** Enable verbose debug logging. */
|
||||
bool debug = false;
|
||||
/** Execution provider such as `"cpu"`. */
|
||||
std::string provider = "cpu";
|
||||
};
|
||||
|
||||
/** @brief RAII wrapper for speaker embedding extraction. */
|
||||
class SHERPA_ONNX_API SpeakerEmbeddingExtractor
|
||||
: public MoveOnly<SpeakerEmbeddingExtractor,
|
||||
SherpaOnnxSpeakerEmbeddingExtractor> {
|
||||
public:
|
||||
/** @brief Create a speaker embedding extractor. */
|
||||
static SpeakerEmbeddingExtractor Create(
|
||||
const SpeakerEmbeddingExtractorConfig &config);
|
||||
|
||||
/** @brief Destroy the wrapped C handle. */
|
||||
void Destroy(const SherpaOnnxSpeakerEmbeddingExtractor *p) const;
|
||||
|
||||
/** @brief Return the embedding dimension. */
|
||||
int32_t Dim() const;
|
||||
|
||||
/** @brief Create a stream for embedding extraction. */
|
||||
OnlineStream CreateStream() const;
|
||||
|
||||
/** @brief Check whether enough audio has been provided. */
|
||||
bool IsReady(const OnlineStream *s) const;
|
||||
|
||||
/** @brief Compute the embedding for a stream. */
|
||||
std::vector<float> ComputeEmbedding(const OnlineStream *s) const;
|
||||
|
||||
private:
|
||||
explicit SpeakerEmbeddingExtractor(
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *p);
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// Speaker Embedding Manager
|
||||
// ============================================================================
|
||||
|
||||
/** @brief One speaker match returned by the best-matches API. */
|
||||
struct SpeakerMatch {
|
||||
/** Similarity score. Larger means more similar. */
|
||||
float score;
|
||||
/** Speaker name. */
|
||||
std::string name;
|
||||
};
|
||||
|
||||
/** @brief RAII wrapper for speaker embedding management. */
|
||||
class SHERPA_ONNX_API SpeakerEmbeddingManager
|
||||
: public MoveOnly<SpeakerEmbeddingManager,
|
||||
SherpaOnnxSpeakerEmbeddingManager> {
|
||||
public:
|
||||
/** @brief Create a speaker embedding manager. */
|
||||
static SpeakerEmbeddingManager Create(int32_t dim);
|
||||
|
||||
/** @brief Destroy the wrapped C handle. */
|
||||
void Destroy(const SherpaOnnxSpeakerEmbeddingManager *p) const;
|
||||
|
||||
/** @brief Add one enrollment embedding for a speaker. */
|
||||
bool Add(const std::string &name, const float *v) const;
|
||||
|
||||
/** @brief Add multiple enrollment embeddings for one speaker. */
|
||||
bool AddList(const std::string &name, const float **v) const;
|
||||
|
||||
/** @brief Add multiple enrollment embeddings packed in one flat array. */
|
||||
bool AddListFlattened(const std::string &name, const float *v,
|
||||
int32_t n) const;
|
||||
|
||||
/** @brief Remove a speaker from the manager. */
|
||||
bool Remove(const std::string &name) const;
|
||||
|
||||
/** @brief Search for the best matching enrolled speaker. */
|
||||
std::string Search(const float *v, float threshold) const;
|
||||
|
||||
/** @brief Return up to n best matches above a similarity threshold. */
|
||||
std::vector<SpeakerMatch> GetBestMatches(const float *v, float threshold,
|
||||
int32_t n) const;
|
||||
|
||||
/** @brief Verify whether a query embedding matches a named speaker. */
|
||||
bool Verify(const std::string &name, const float *v, float threshold) const;
|
||||
|
||||
/** @brief Check whether a speaker is enrolled. */
|
||||
bool Contains(const std::string &name) const;
|
||||
|
||||
/** @brief Return the number of enrolled speakers. */
|
||||
int32_t NumSpeakers() const;
|
||||
|
||||
/** @brief Return all enrolled speaker names. */
|
||||
std::vector<std::string> GetAllSpeakers() const;
|
||||
|
||||
private:
|
||||
explicit SpeakerEmbeddingManager(const SherpaOnnxSpeakerEmbeddingManager *p);
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// Offline Speaker Diarization
|
||||
// ============================================================================
|
||||
|
||||
/** @brief Pyannote segmentation model configuration. */
|
||||
struct OfflineSpeakerSegmentationPyannoteModelConfig {
|
||||
/** Segmentation model filename. */
|
||||
std::string model;
|
||||
};
|
||||
|
||||
/** @brief Segmentation model configuration for offline speaker diarization. */
|
||||
struct OfflineSpeakerSegmentationModelConfig {
|
||||
/** Pyannote segmentation model configuration. */
|
||||
OfflineSpeakerSegmentationPyannoteModelConfig pyannote;
|
||||
/** Number of inference threads. */
|
||||
int32_t num_threads = 1;
|
||||
/** Enable verbose debug logging. */
|
||||
bool debug = false;
|
||||
/** Execution provider such as `"cpu"`. */
|
||||
std::string provider = "cpu";
|
||||
};
|
||||
|
||||
/** @brief Fast clustering configuration. */
|
||||
struct FastClusteringConfig {
|
||||
/** Known number of speakers. If > 0, threshold-based clustering is bypassed.
|
||||
*/
|
||||
int32_t num_clusters = 0;
|
||||
/** Distance threshold used when the number of speakers is unknown. */
|
||||
float threshold = 0.5;
|
||||
};
|
||||
|
||||
/** @brief Configuration for offline speaker diarization. */
|
||||
struct OfflineSpeakerDiarizationConfig {
|
||||
/** Speaker segmentation model configuration. */
|
||||
OfflineSpeakerSegmentationModelConfig segmentation;
|
||||
/** Speaker embedding extractor configuration. */
|
||||
SpeakerEmbeddingExtractorConfig embedding;
|
||||
/** Clustering configuration. */
|
||||
FastClusteringConfig clustering;
|
||||
/** Segments shorter than this duration in seconds are discarded. */
|
||||
float min_duration_on = 0;
|
||||
/** Small gaps shorter than this duration in seconds may be merged. */
|
||||
float min_duration_off = 0;
|
||||
};
|
||||
|
||||
/** @brief One diarization segment. */
|
||||
struct OfflineSpeakerDiarizationSegment {
|
||||
/** Segment start time in seconds. */
|
||||
float start;
|
||||
/** Segment end time in seconds. */
|
||||
float end;
|
||||
/** Speaker label, typically an integer cluster ID. */
|
||||
int32_t speaker;
|
||||
};
|
||||
|
||||
/** @brief Progress callback for offline speaker diarization. */
|
||||
using OfflineSpeakerDiarizationProgressCallback =
|
||||
std::function<void(int32_t num_processed_chunks, int32_t num_total_chunks)>;
|
||||
|
||||
/** @brief RAII wrapper for offline speaker diarization. */
|
||||
class SHERPA_ONNX_API OfflineSpeakerDiarization
|
||||
: public MoveOnly<OfflineSpeakerDiarization,
|
||||
SherpaOnnxOfflineSpeakerDiarization> {
|
||||
public:
|
||||
/** @brief Create an offline speaker diarization pipeline. */
|
||||
static OfflineSpeakerDiarization Create(
|
||||
const OfflineSpeakerDiarizationConfig &config);
|
||||
|
||||
/** @brief Destroy the wrapped C handle. */
|
||||
void Destroy(const SherpaOnnxOfflineSpeakerDiarization *p) const;
|
||||
|
||||
/** @brief Return the expected input sample rate. */
|
||||
int32_t GetSampleRate() const;
|
||||
|
||||
/** @brief Update clustering-related settings. */
|
||||
void SetConfig(const OfflineSpeakerDiarizationConfig &config) const;
|
||||
|
||||
/** @brief Run offline speaker diarization. */
|
||||
std::vector<OfflineSpeakerDiarizationSegment> Process(
|
||||
const float *samples, int32_t n) const;
|
||||
|
||||
/** @brief Run offline speaker diarization with a progress callback. */
|
||||
std::vector<OfflineSpeakerDiarizationSegment> Process(
|
||||
const float *samples, int32_t n,
|
||||
const OfflineSpeakerDiarizationProgressCallback &callback) const;
|
||||
|
||||
private:
|
||||
explicit OfflineSpeakerDiarization(
|
||||
const SherpaOnnxOfflineSpeakerDiarization *p);
|
||||
};
|
||||
|
||||
} // namespace sherpa_onnx::cxx
|
||||
|
||||
#endif // SHERPA_ONNX_C_API_CXX_API_H_
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
@page audio_tagging Audio Tagging
|
||||
|
||||
sherpa-onnx supports audio tagging through the
|
||||
@ref SherpaOnnxCreateAudioTagging() API. Configure exactly one model
|
||||
family by filling in the corresponding field of
|
||||
@ref SherpaOnnxAudioTaggingModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateAudioTagging, SherpaOnnxAudioTaggingConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section audio_tagging_zipformer Zipformer
|
||||
|
||||
The Zipformer audio tagging model uses a CSV file for class labels.
|
||||
|
||||
@code
|
||||
SherpaOnnxAudioTaggingConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.zipformer.model =
|
||||
"./sherpa-onnx-zipformer-audio-tagging-2024-04-09/model.int8.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
config.labels =
|
||||
"./sherpa-onnx-zipformer-audio-tagging-2024-04-09/class_labels_indices.csv";
|
||||
config.top_k = 5;
|
||||
|
||||
const SherpaOnnxAudioTagging *tagger = SherpaOnnxCreateAudioTagging(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-zipformer-audio-tagging-2024-04-09`
|
||||
|
||||
Example source: [audio-tagging-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/audio-tagging-c-api.c)
|
||||
|
||||
@section audio_tagging_ced CED
|
||||
|
||||
CED (Conditional Event Detection) is an alternative audio tagging model.
|
||||
|
||||
@code
|
||||
SherpaOnnxAudioTaggingConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.ced = "./sherpa-onnx-audio-tagging-ced-mini-int8/model.int8.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
config.top_k = 5;
|
||||
|
||||
const SherpaOnnxAudioTagging *tagger = SherpaOnnxCreateAudioTagging(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-audio-tagging-ced-mini-int8`
|
||||
*/
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
@page keyword_spotting Keyword Spotting
|
||||
|
||||
sherpa-onnx supports keyword spotting through the
|
||||
@ref SherpaOnnxCreateKeywordSpotter() API. It uses streaming transducer
|
||||
models with keyword lists.
|
||||
|
||||
@see SherpaOnnxCreateKeywordSpotter, SherpaOnnxKeywordSpotterConfig
|
||||
|
||||
@code
|
||||
SherpaOnnxKeywordSpotterConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/"
|
||||
"encoder-epoch-12-avg-2-chunk-16-left-64.int8.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/"
|
||||
"decoder-epoch-12-avg-2-chunk-16-left-64.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/"
|
||||
"joiner-epoch-12-avg-2-chunk-16-left-64.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.keywords_file =
|
||||
"./sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/"
|
||||
"test_wavs/test_keywords.txt";
|
||||
config.max_active_paths = 4;
|
||||
config.keywords_score = 3.0f;
|
||||
config.keywords_threshold = 0.1f;
|
||||
|
||||
const SherpaOnnxKeywordSpotter *kws =
|
||||
SherpaOnnxCreateKeywordSpotter(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile`
|
||||
|
||||
Example source: [kws-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/kws-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,402 @@
|
||||
/**
|
||||
@page offline_asr Non-Streaming (Offline) ASR Models
|
||||
|
||||
sherpa-onnx supports many non-streaming ASR model families through the
|
||||
@ref SherpaOnnxCreateOfflineRecognizer() API. Configure exactly one model
|
||||
family by filling in the corresponding sub-struct of
|
||||
@ref SherpaOnnxOfflineModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateOfflineRecognizer, SherpaOnnxOfflineRecognizerConfig,
|
||||
SherpaOnnxOfflineModelConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section offline_asr_zipformer_transducer Zipformer Transducer
|
||||
|
||||
Zipformer transducer is a general-purpose offline ASR model using the
|
||||
encoder-decoder-joiner architecture.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineRecognizerConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.feat_config.sample_rate = 16000;
|
||||
config.feat_config.feature_dim = 80;
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-zipformer-small-en-2023-06-26/encoder-epoch-99-avg-1.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-zipformer-small-en-2023-06-26/decoder-epoch-99-avg-1.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-zipformer-small-en-2023-06-26/joiner-epoch-99-avg-1.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-zipformer-small-en-2023-06-26/tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-zipformer-small-en-2023-06-26`
|
||||
|
||||
Example source: [zipformer-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/zipformer-c-api.c)
|
||||
|
||||
@section offline_asr_zipformer_ctc Zipformer CTC
|
||||
|
||||
Zipformer CTC uses CTC decoding instead of transducer decoding.
|
||||
|
||||
@code
|
||||
config.model_config.zipformer_ctc.model =
|
||||
"./sherpa-onnx-zipformer-ctc-zh-int8-2025-07-03/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-zipformer-ctc-zh-int8-2025-07-03/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-zipformer-ctc-zh-int8-2025-07-03`
|
||||
|
||||
@section offline_asr_whisper Whisper
|
||||
|
||||
Whisper is OpenAI's general-purpose speech recognition model.
|
||||
It supports language hints and translation.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineRecognizerConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.feat_config.sample_rate = 16000;
|
||||
config.feat_config.feature_dim = 80;
|
||||
config.model_config.whisper.encoder =
|
||||
"./sherpa-onnx-whisper-tiny/tiny-encoder.onnx";
|
||||
config.model_config.whisper.decoder =
|
||||
"./sherpa-onnx-whisper-tiny/tiny-decoder.onnx";
|
||||
config.model_config.whisper.language = "en";
|
||||
config.model_config.whisper.task = "transcribe";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-whisper-tiny/tiny-tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
|
||||
const SherpaOnnxOfflineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOfflineRecognizer(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-whisper-tiny`
|
||||
|
||||
Example source: [whisper-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/whisper-c-api.c)
|
||||
|
||||
@section offline_asr_sense_voice SenseVoice
|
||||
|
||||
SenseVoice is a multilingual model supporting Chinese, English, Japanese,
|
||||
Korean, and Cantonese. It supports automatic language detection and
|
||||
inverse text normalization.
|
||||
|
||||
@code
|
||||
config.model_config.sense_voice.model =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17-int8/model.int8.onnx";
|
||||
config.model_config.sense_voice.language = "auto";
|
||||
config.model_config.sense_voice.use_itn = 1;
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17-int8/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17-int8`
|
||||
|
||||
Example source: [sense-voice-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/sense-voice-c-api.c)
|
||||
|
||||
@section offline_asr_parakeet NeMo Parakeet TDT
|
||||
|
||||
Parakeet TDT is an NVIDIA NeMo transducer model. Set `model_type` to
|
||||
`"nemo_transducer"` so the runtime selects the correct decoder
|
||||
implementation.
|
||||
|
||||
@code
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/encoder.int8.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/decoder.int8.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/joiner.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8/tokens.txt";
|
||||
config.model_config.model_type = "nemo_transducer";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8`
|
||||
|
||||
Example source: [nemo-parakeet-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-parakeet-c-api.c)
|
||||
|
||||
@section offline_asr_giga_am GigaAM v2 (NeMo Transducer, Russian)
|
||||
|
||||
GigaAM v2 is a NeMo transducer model for Russian speech recognition.
|
||||
Like Parakeet, set `model_type` to `"nemo_transducer"`.
|
||||
|
||||
@code
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"encoder.int8.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"decoder.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"joiner.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19/"
|
||||
"tokens.txt";
|
||||
config.model_config.model_type = "nemo_transducer";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-nemo-transducer-giga-am-v2-russian-2025-04-19`
|
||||
|
||||
Example source: [nemo-giga-am-v2-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-giga-am-v2-c-api.c)
|
||||
|
||||
@section offline_asr_nemo_ctc NeMo CTC
|
||||
|
||||
NeMo CTC models use CTC decoding. They are simpler than NeMo transducer
|
||||
models (no joiner network).
|
||||
|
||||
@code
|
||||
config.model_config.nemo_ctc.model =
|
||||
"./sherpa-onnx-nemo-ctc-en-citrinet-512/model.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemo-ctc-en-citrinet-512/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-nemo-ctc-en-citrinet-512`
|
||||
|
||||
Example source: [nemo-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_paraformer Paraformer
|
||||
|
||||
Paraformer is a non-autoregressive ASR model from FunASR.
|
||||
|
||||
@code
|
||||
config.model_config.paraformer.model =
|
||||
"./sherpa-onnx-paraformer-zh-small-2024-03-09/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-paraformer-zh-small-2024-03-09/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-paraformer-zh-small-2024-03-09`
|
||||
|
||||
Example source: [paraformer-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/paraformer-c-api.c)
|
||||
|
||||
@section offline_asr_moonshine Moonshine
|
||||
|
||||
Moonshine is a compact speech recognition model. It uses a preprocessor,
|
||||
encoder, and decoder (cached or uncached).
|
||||
|
||||
@code
|
||||
config.model_config.moonshine.preprocessor =
|
||||
"./sherpa-onnx-moonshine-tiny-en-int8/preprocess.onnx";
|
||||
config.model_config.moonshine.encoder =
|
||||
"./sherpa-onnx-moonshine-tiny-en-int8/encode.int8.onnx";
|
||||
config.model_config.moonshine.uncached_decoder =
|
||||
"./sherpa-onnx-moonshine-tiny-en-int8/uncached_decode.int8.onnx";
|
||||
config.model_config.moonshine.cached_decoder =
|
||||
"./sherpa-onnx-moonshine-tiny-en-int8/cached_decode.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-moonshine-tiny-en-int8/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-moonshine-tiny-en-int8`
|
||||
|
||||
Example source: [moonshine-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/moonshine-c-api.c)
|
||||
|
||||
@section offline_asr_fire_red FireRedAsr
|
||||
|
||||
FireRedAsr is an encoder-decoder ASR model supporting Chinese and English.
|
||||
|
||||
@code
|
||||
config.model_config.fire_red_asr.encoder =
|
||||
"./sherpa-onnx-fire-red-asr-large-zh_en-2025-02-16/encoder.int8.onnx";
|
||||
config.model_config.fire_red_asr.decoder =
|
||||
"./sherpa-onnx-fire-red-asr-large-zh_en-2025-02-16/decoder.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-fire-red-asr-large-zh_en-2025-02-16/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-fire-red-asr-large-zh_en-2025-02-16`
|
||||
|
||||
Example source: [fire-red-asr-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/fire-red-asr-c-api.c)
|
||||
|
||||
@section offline_asr_fire_red_ctc FireRedAsr CTC
|
||||
|
||||
CTC variant of FireRedAsr.
|
||||
|
||||
@code
|
||||
config.model_config.fire_red_asr_ctc.model =
|
||||
"./sherpa-onnx-fire-red-asr2-ctc-zh_en-int8-2026-02-25/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-fire-red-asr2-ctc-zh_en-int8-2026-02-25/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-fire-red-asr2-ctc-zh_en-int8-2026-02-25`
|
||||
|
||||
Example source: [fire-red-asr-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/fire-red-asr-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_dolphin Dolphin
|
||||
|
||||
Dolphin is a multilingual CTC model.
|
||||
|
||||
@code
|
||||
config.model_config.dolphin.model =
|
||||
"./sherpa-onnx-dolphin-base-ctc-multi-lang-int8-2025-04-02/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-dolphin-base-ctc-multi-lang-int8-2025-04-02/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-dolphin-base-ctc-multi-lang-int8-2025-04-02`
|
||||
|
||||
Example source: [dolphin-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/dolphin-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_canary NeMo Canary
|
||||
|
||||
Canary is an NVIDIA NeMo model supporting English, Spanish, German, and
|
||||
French with source/target language selection and punctuation.
|
||||
|
||||
@code
|
||||
config.model_config.canary.encoder =
|
||||
"./sherpa-onnx-nemo-canary-180m-flash-en-es-de-fr-int8/encoder.int8.onnx";
|
||||
config.model_config.canary.decoder =
|
||||
"./sherpa-onnx-nemo-canary-180m-flash-en-es-de-fr-int8/decoder.int8.onnx";
|
||||
config.model_config.canary.src_lang = "de";
|
||||
config.model_config.canary.tgt_lang = "en";
|
||||
config.model_config.canary.use_pnc = 1;
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemo-canary-180m-flash-en-es-de-fr-int8/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-nemo-canary-180m-flash-en-es-de-fr-int8`
|
||||
|
||||
Example source: [nemo-canary-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-canary-c-api.c)
|
||||
|
||||
@section offline_asr_cohere Cohere Transcribe
|
||||
|
||||
Cohere Transcribe is a multilingual encoder-decoder model with built-in
|
||||
punctuation and inverse text normalization.
|
||||
|
||||
@code
|
||||
config.model_config.cohere_transcribe.encoder =
|
||||
"./sherpa-onnx-cohere-transcribe-14-lang-int8-2026-04-01/encoder.int8.onnx";
|
||||
config.model_config.cohere_transcribe.decoder =
|
||||
"./sherpa-onnx-cohere-transcribe-14-lang-int8-2026-04-01/decoder.int8.onnx";
|
||||
config.model_config.cohere_transcribe.use_punct = 1;
|
||||
config.model_config.cohere_transcribe.use_itn = 1;
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-cohere-transcribe-14-lang-int8-2026-04-01/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-cohere-transcribe-14-lang-int8-2026-04-01`
|
||||
|
||||
Example source: [cohere-transcribe-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/cohere-transcribe-c-api.c)
|
||||
|
||||
@section offline_asr_wenet WeNet CTC
|
||||
|
||||
WeNet CTC models support Chinese, English, and Cantonese.
|
||||
|
||||
@code
|
||||
config.model_config.wenet_ctc.model =
|
||||
"./sherpa-onnx-wenetspeech-yue-u2pp-conformer-ctc-zh-en-cantonese-int8-2025-09-10/"
|
||||
"model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-wenetspeech-yue-u2pp-conformer-ctc-zh-en-cantonese-int8-2025-09-10/"
|
||||
"tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-wenetspeech-yue-u2pp-conformer-ctc-zh-en-cantonese-int8-2025-09-10`
|
||||
|
||||
Example source: [wenet-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/wenet-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_omnilingual Omnilingual
|
||||
|
||||
Omnilingual is a CTC model supporting 1600 languages.
|
||||
|
||||
@code
|
||||
config.model_config.omnilingual.model =
|
||||
"./sherpa-onnx-omnilingual-asr-1600-languages-300M-ctc-int8-2025-11-12/"
|
||||
"model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-omnilingual-asr-1600-languages-300M-ctc-int8-2025-11-12/"
|
||||
"tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-omnilingual-asr-1600-languages-300M-ctc-int8-2025-11-12`
|
||||
|
||||
Example source: [omnilingual-asr-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/omnilingual-asr-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_funasr FunASR Nano
|
||||
|
||||
FunASR Nano is an LLM-based ASR model from FunASR.
|
||||
|
||||
@code
|
||||
config.model_config.funasr_nano.encoder_adaptor =
|
||||
"./sherpa-onnx-funasr-nano-int8-2025-12-30/encoder_adaptor.int8.onnx";
|
||||
config.model_config.funasr_nano.embedding =
|
||||
"./sherpa-onnx-funasr-nano-int8-2025-12-30/embedding.int8.onnx";
|
||||
config.model_config.funasr_nano.llm =
|
||||
"./sherpa-onnx-funasr-nano-int8-2025-12-30/llm.int8.onnx";
|
||||
config.model_config.funasr_nano.tokenizer =
|
||||
"./sherpa-onnx-funasr-nano-int8-2025-12-30/Qwen3-0.6B";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-funasr-nano-int8-2025-12-30/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-funasr-nano-int8-2025-12-30`
|
||||
|
||||
Example source: [funasr-nano-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/funasr-nano-c-api.c)
|
||||
|
||||
@section offline_asr_qwen3 Qwen3-ASR
|
||||
|
||||
Qwen3-ASR is an LLM-based ASR model from Alibaba.
|
||||
|
||||
@code
|
||||
config.model_config.qwen3_asr.conv_frontend =
|
||||
"./sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25/conv_frontend.onnx";
|
||||
config.model_config.qwen3_asr.encoder =
|
||||
"./sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25/encoder.int8.onnx";
|
||||
config.model_config.qwen3_asr.decoder =
|
||||
"./sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25/decoder.int8.onnx";
|
||||
config.model_config.qwen3_asr.tokenizer =
|
||||
"./sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25/tokenizer";
|
||||
config.model_config.qwen3_asr.max_total_len = 512;
|
||||
config.model_config.qwen3_asr.max_new_tokens = 128;
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25`
|
||||
|
||||
Example source: [qwen3-asr-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/qwen3-asr-c-api.c)
|
||||
|
||||
@section offline_asr_medasr MedASR
|
||||
|
||||
MedASR is a medical-domain CTC model.
|
||||
|
||||
@code
|
||||
config.model_config.medasr.model =
|
||||
"./sherpa-onnx-medasr-ctc-en-int8-2025-12-25/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-medasr-ctc-en-int8-2025-12-25/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-medasr-ctc-en-int8-2025-12-25`
|
||||
|
||||
Example source: [medasr-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/medasr-ctc-c-api.c)
|
||||
|
||||
@section offline_asr_telespeech TeleSpeech CTC
|
||||
|
||||
TeleSpeech is a Chinese CTC model. Note the simple string assignment
|
||||
for the model path.
|
||||
|
||||
@code
|
||||
config.model_config.telespeech_ctc =
|
||||
"./sherpa-onnx-telespeech-ctc-int8-zh-2024-06-04/model.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-telespeech-ctc-int8-zh-2024-06-04/tokens.txt";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-telespeech-ctc-int8-zh-2024-06-04`
|
||||
|
||||
Example source: [telespeech-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/telespeech-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,136 @@
|
||||
/**
|
||||
@page online_asr Streaming (Online) ASR Models
|
||||
|
||||
sherpa-onnx supports several streaming ASR model families through the
|
||||
@ref SherpaOnnxCreateOnlineRecognizer() API. Configure exactly one model
|
||||
family by filling in the corresponding sub-struct of
|
||||
@ref SherpaOnnxOnlineModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateOnlineRecognizer, SherpaOnnxOnlineRecognizerConfig,
|
||||
SherpaOnnxOnlineModelConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section online_asr_transducer Transducer (Zipformer)
|
||||
|
||||
Streaming Zipformer transducer models are the most widely used streaming
|
||||
ASR models in sherpa-onnx.
|
||||
|
||||
@code
|
||||
SherpaOnnxOnlineRecognizerConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.feat_config.sample_rate = 16000;
|
||||
config.feat_config.feature_dim = 80;
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20/"
|
||||
"encoder-epoch-99-avg-1.int8.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20/"
|
||||
"decoder-epoch-99-avg-1.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20/"
|
||||
"joiner-epoch-99-avg-1.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20/tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
|
||||
const SherpaOnnxOnlineRecognizer *recognizer =
|
||||
SherpaOnnxCreateOnlineRecognizer(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-streaming-zipformer-bilingual-zh-en-2023-02-20`
|
||||
|
||||
Example source: [streaming-zipformer-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-zipformer-c-api.c)
|
||||
|
||||
@section online_asr_nemotron Nemotron (NeMo Transducer)
|
||||
|
||||
Nemotron is an NVIDIA NeMo streaming transducer model. The runtime
|
||||
auto-detects NeMo transducer models from the decoder's output node count,
|
||||
so no `model_type` string is needed.
|
||||
|
||||
@code
|
||||
config.model_config.transducer.encoder =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"encoder.int8.onnx";
|
||||
config.model_config.transducer.decoder =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"decoder.int8.onnx";
|
||||
config.model_config.transducer.joiner =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"joiner.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25/"
|
||||
"tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-nemotron-speech-streaming-en-0.6b-560ms-int8-2026-04-25`
|
||||
|
||||
Available variants: 80ms, 160ms, 560ms, 1120ms chunk sizes.
|
||||
|
||||
Example source: [streaming-nemotron-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-nemotron-c-api.c)
|
||||
|
||||
@section online_asr_paraformer Streaming Paraformer
|
||||
|
||||
Streaming Paraformer is a non-autoregressive streaming ASR model from
|
||||
FunASR.
|
||||
|
||||
@code
|
||||
config.model_config.paraformer.encoder =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/encoder.int8.onnx";
|
||||
config.model_config.paraformer.decoder =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/decoder.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-streaming-paraformer-bilingual-zh-en/tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-streaming-paraformer-bilingual-zh-en`
|
||||
|
||||
Example source: [streaming-paraformer-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-paraformer-c-api.c)
|
||||
|
||||
@section online_asr_zipformer2_ctc Zipformer2 CTC
|
||||
|
||||
Streaming Zipformer2 CTC models use CTC decoding instead of transducer
|
||||
decoding.
|
||||
|
||||
@code
|
||||
config.model_config.zipformer2_ctc.model =
|
||||
"./sherpa-onnx-streaming-zipformer-ctc-multi-zh-hans-2023-12-13/"
|
||||
"ctc-epoch-20-avg-1-chunk-16-left-128.int8.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-streaming-zipformer-ctc-multi-zh-hans-2023-12-13/"
|
||||
"tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-streaming-zipformer-ctc-multi-zh-hans-2023-12-13`
|
||||
|
||||
Example source: [streaming-ctc-buffered-tokens-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-ctc-buffered-tokens-c-api.c)
|
||||
|
||||
@section online_asr_t_one T-One CTC
|
||||
|
||||
T-One is a streaming CTC model for Russian.
|
||||
|
||||
@code
|
||||
config.model_config.t_one_ctc.model =
|
||||
"./sherpa-onnx-streaming-t-one-russian-2025-09-08/model.onnx";
|
||||
config.model_config.tokens =
|
||||
"./sherpa-onnx-streaming-t-one-russian-2025-09-08/tokens.txt";
|
||||
config.model_config.provider = "cpu";
|
||||
config.model_config.num_threads = 1;
|
||||
config.decoding_method = "greedy_search";
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-streaming-t-one-russian-2025-09-08`
|
||||
|
||||
Example source: [streaming-t-one-ctc-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-t-one-ctc-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
@page punctuation Punctuation Restoration
|
||||
|
||||
sherpa-onnx supports both offline and online punctuation restoration.
|
||||
|
||||
@see SherpaOnnxCreateOfflinePunctuation, SherpaOnnxCreateOnlinePunctuation
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section punct_offline Offline Punctuation
|
||||
|
||||
Offline punctuation processes the entire input text at once using a
|
||||
CT-Transformer model.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflinePunctuationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.ct_transformer =
|
||||
"./sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8/model.int8.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOfflinePunctuation *punct =
|
||||
SherpaOnnxCreateOfflinePunctuation(&config);
|
||||
|
||||
const char *result = SherpaOfflinePunctuationAddPunct(
|
||||
punct, "how are you i am fine thank you");
|
||||
printf("%s\n", result);
|
||||
SherpaOfflinePunctuationFreeText(result);
|
||||
SherpaOnnxDestroyOfflinePunctuation(punct);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-punct-ct-transformer-zh-en-vocab272727-2024-04-12-int8`
|
||||
|
||||
Example source: [add-punctuation-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/add-punctuation-c-api.c)
|
||||
|
||||
@section punct_online Online Punctuation
|
||||
|
||||
Online punctuation processes text incrementally using a CNN-BiLSTM model.
|
||||
|
||||
@code
|
||||
SherpaOnnxOnlinePunctuationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.cnn_bilstm =
|
||||
"./sherpa-onnx-online-punct-en-2024-08-06/model.int8.onnx";
|
||||
config.model.bpe_vocab =
|
||||
"./sherpa-onnx-online-punct-en-2024-08-06/bpe.vocab";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOnlinePunctuation *punct =
|
||||
SherpaOnnxCreateOnlinePunctuation(&config);
|
||||
|
||||
const char *out = SherpaOnnxOnlinePunctuationAddPunct(
|
||||
punct, "how are you i am fine thank you");
|
||||
printf("%s\n", out);
|
||||
SherpaOnnxOnlinePunctuationFreeText(out);
|
||||
SherpaOnnxDestroyOnlinePunctuation(punct);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-online-punct-en-2024-08-06`
|
||||
|
||||
Example source: [add-punctuation-online-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/add-punctuation-online-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,34 @@
|
||||
/**
|
||||
@page resampler Linear Resampler
|
||||
|
||||
sherpa-onnx provides a linear resampler for sample rate conversion through
|
||||
the @ref SherpaOnnxCreateLinearResampler() API.
|
||||
|
||||
@see SherpaOnnxCreateLinearResampler, SherpaOnnxDestroyLinearResampler
|
||||
|
||||
@code
|
||||
const SherpaOnnxLinearResampler *resampler =
|
||||
SherpaOnnxCreateLinearResampler(48000, 16000, 0, 0);
|
||||
|
||||
// Process intermediate chunks (flush = 0)
|
||||
const SherpaOnnxResampleOut *out =
|
||||
SherpaOnnxLinearResamplerResample(resampler, input_samples, n, 0);
|
||||
// Use out->samples[0..out->n-1]
|
||||
SherpaOnnxLinearResamplerResampleFree(out);
|
||||
|
||||
// Flush the final chunk (flush = 1)
|
||||
out = SherpaOnnxLinearResamplerResample(resampler, last_chunk, last_n, 1);
|
||||
SherpaOnnxLinearResamplerResampleFree(out);
|
||||
|
||||
SherpaOnnxDestroyLinearResampler(resampler);
|
||||
@endcode
|
||||
|
||||
If `filter_cutoff_hz` or `num_zeros` is 0, default values are used:
|
||||
|
||||
@code
|
||||
float min_freq = samp_rate_in_hz < samp_rate_out_hz ? samp_rate_in_hz
|
||||
: samp_rate_out_hz;
|
||||
float filter_cutoff_hz = 0.99f * 0.5f * min_freq;
|
||||
int32_t num_zeros = 6;
|
||||
@endcode
|
||||
*/
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
@page source_separation Source Separation
|
||||
|
||||
sherpa-onnx supports source separation through the
|
||||
@ref SherpaOnnxCreateOfflineSourceSeparation() API. Configure exactly one
|
||||
model family by filling in the corresponding field of
|
||||
@ref SherpaOnnxOfflineSourceSeparationModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateOfflineSourceSeparation,
|
||||
SherpaOnnxOfflineSourceSeparationConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section ss_spleeter Spleeter
|
||||
|
||||
Spleeter separates audio into vocals and accompaniment (2 stems).
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineSourceSeparationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.spleeter.vocals =
|
||||
"./sherpa-onnx-spleeter-2stems-fp16/vocals.fp16.onnx";
|
||||
config.model.spleeter.accompaniment =
|
||||
"./sherpa-onnx-spleeter-2stems-fp16/accompaniment.fp16.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOfflineSourceSeparation *ss =
|
||||
SherpaOnnxCreateOfflineSourceSeparation(&config);
|
||||
// ... use ss ...
|
||||
SherpaOnnxDestroyOfflineSourceSeparation(ss);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-spleeter-2stems-fp16`
|
||||
|
||||
Example source: [source-separation-spleeter-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/source-separation-spleeter-c-api.c)
|
||||
|
||||
@section ss_uvr UVR (MDX-Net)
|
||||
|
||||
UVR separates audio into vocals and non-vocals.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineSourceSeparationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.uvr.model = "./UVR-MDX-NET-Voc_FT.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOfflineSourceSeparation *ss =
|
||||
SherpaOnnxCreateOfflineSourceSeparation(&config);
|
||||
// ... use ss ...
|
||||
SherpaOnnxDestroyOfflineSourceSeparation(ss);
|
||||
@endcode
|
||||
|
||||
Model file: `UVR-MDX-NET-Voc_FT.onnx`
|
||||
|
||||
Example source: [source-separation-uvr-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/source-separation-uvr-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,48 @@
|
||||
/**
|
||||
@page speaker_diarization Offline Speaker Diarization
|
||||
|
||||
sherpa-onnx supports offline speaker diarization through the
|
||||
@ref SherpaOnnxCreateOfflineSpeakerDiarization() API. It combines a
|
||||
segmentation model, a speaker embedding extractor, and a clustering
|
||||
algorithm.
|
||||
|
||||
@see SherpaOnnxCreateOfflineSpeakerDiarization,
|
||||
SherpaOnnxOfflineSpeakerDiarizationConfig
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineSpeakerDiarizationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.segmentation.pyannote.model =
|
||||
"./sherpa-onnx-pyannote-segmentation-3-0/model.onnx";
|
||||
config.embedding.model =
|
||||
"./3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx";
|
||||
config.clustering.num_clusters = 4;
|
||||
|
||||
const SherpaOnnxOfflineSpeakerDiarization *sd =
|
||||
SherpaOnnxCreateOfflineSpeakerDiarization(&config);
|
||||
|
||||
const SherpaOnnxWave *wave = SherpaOnnxReadWave("./meeting.wav");
|
||||
const SherpaOnnxOfflineSpeakerDiarizationResult *result =
|
||||
SherpaOnnxOfflineSpeakerDiarizationProcess(sd, wave->samples,
|
||||
wave->num_samples);
|
||||
|
||||
const SherpaOnnxOfflineSpeakerDiarizationSegment *segments =
|
||||
SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime(result);
|
||||
int32_t n = SherpaOnnxOfflineSpeakerDiarizationResultGetNumSegments(result);
|
||||
for (int32_t i = 0; i < n; ++i) {
|
||||
printf("Speaker %d: %.2f - %.2f\n", segments[i].speaker,
|
||||
segments[i].start, segments[i].end);
|
||||
}
|
||||
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroySegment(segments);
|
||||
SherpaOnnxOfflineSpeakerDiarizationDestroyResult(result);
|
||||
SherpaOnnxFreeWave(wave);
|
||||
SherpaOnnxDestroyOfflineSpeakerDiarization(sd);
|
||||
@endcode
|
||||
|
||||
Segmentation model: `sherpa-onnx-pyannote-segmentation-3-0/model.onnx`
|
||||
|
||||
Embedding model: `3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx`
|
||||
|
||||
Example source: [offline-speaker-diarization-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/offline-speaker-diarization-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
@page speaker_embedding Speaker Embedding Extraction and Management
|
||||
|
||||
sherpa-onnx provides speaker embedding extraction via
|
||||
@ref SherpaOnnxCreateSpeakerEmbeddingExtractor() and speaker
|
||||
enrollment/search/verification via
|
||||
@ref SherpaOnnxCreateSpeakerEmbeddingManager().
|
||||
|
||||
@see SherpaOnnxCreateSpeakerEmbeddingExtractor,
|
||||
SherpaOnnxSpeakerEmbeddingExtractorConfig,
|
||||
SherpaOnnxCreateSpeakerEmbeddingManager
|
||||
|
||||
@code
|
||||
SherpaOnnxSpeakerEmbeddingExtractorConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model = "./3dspeaker_speech_campplus_sv_zh-cn_16k-common.onnx";
|
||||
config.num_threads = 1;
|
||||
config.provider = "cpu";
|
||||
|
||||
const SherpaOnnxSpeakerEmbeddingExtractor *extractor =
|
||||
SherpaOnnxCreateSpeakerEmbeddingExtractor(&config);
|
||||
|
||||
int32_t dim = SherpaOnnxSpeakerEmbeddingExtractorDim(extractor);
|
||||
const SherpaOnnxSpeakerEmbeddingManager *manager =
|
||||
SherpaOnnxCreateSpeakerEmbeddingManager(dim);
|
||||
|
||||
// Enroll a speaker
|
||||
const float *embedding = /* compute from audio */;
|
||||
SherpaOnnxSpeakerEmbeddingManagerAdd(manager, "alice", embedding);
|
||||
SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(embedding);
|
||||
|
||||
// Search for a speaker
|
||||
const float *query = /* compute from test audio */;
|
||||
const char *name = SherpaOnnxSpeakerEmbeddingManagerSearch(
|
||||
manager, query, 0.5f);
|
||||
if (name) {
|
||||
printf("Identified: %s\n", name);
|
||||
SherpaOnnxSpeakerEmbeddingManagerFreeSearch(name);
|
||||
}
|
||||
SherpaOnnxSpeakerEmbeddingExtractorDestroyEmbedding(query);
|
||||
|
||||
SherpaOnnxDestroySpeakerEmbeddingManager(manager);
|
||||
SherpaOnnxDestroySpeakerEmbeddingExtractor(extractor);
|
||||
@endcode
|
||||
|
||||
Model file: `3dspeaker_speech_campplus_sv_zh-cn_16k-common.onnx`
|
||||
|
||||
Example source: [speaker-identification-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/speaker-identification-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
@page speech_enhancement Speech Enhancement / Denoising
|
||||
|
||||
sherpa-onnx supports both offline and online speech enhancement with
|
||||
two model families: GTCRN and DPDFNet.
|
||||
|
||||
@see SherpaOnnxCreateOfflineSpeechDenoiser, SherpaOnnxCreateOnlineSpeechDenoiser
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section se_offline_gtcrn Offline GTCRN
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineSpeechDenoiserConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.gtcrn.model = "./gtcrn_simple.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOfflineSpeechDenoiser *sd =
|
||||
SherpaOnnxCreateOfflineSpeechDenoiser(&config);
|
||||
|
||||
const SherpaOnnxDenoisedAudio *denoised =
|
||||
SherpaOnnxOfflineSpeechDenoiserRun(sd, wave->samples, wave->num_samples,
|
||||
wave->sample_rate);
|
||||
SherpaOnnxWriteWave(denoised->samples, denoised->n, denoised->sample_rate,
|
||||
"./clean.wav");
|
||||
SherpaOnnxDestroyDenoisedAudio(denoised);
|
||||
SherpaOnnxDestroyOfflineSpeechDenoiser(sd);
|
||||
@endcode
|
||||
|
||||
Model file: `gtcrn_simple.onnx`
|
||||
|
||||
Example source: [speech-enhancement-gtcrn-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/speech-enhancement-gtcrn-c-api.c)
|
||||
|
||||
@section se_offline_dpdfnet Offline DPDFNet
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineSpeechDenoiserConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.dpdfnet.model = "./dpdfnet_baseline.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOfflineSpeechDenoiser *sd =
|
||||
SherpaOnnxCreateOfflineSpeechDenoiser(&config);
|
||||
// ... use sd ...
|
||||
SherpaOnnxDestroyOfflineSpeechDenoiser(sd);
|
||||
@endcode
|
||||
|
||||
Model file: `dpdfnet_baseline.onnx` (also: `dpdfnet2.onnx`, `dpdfnet4.onnx`,
|
||||
`dpdfnet8.onnx` for 16 kHz; `dpdfnet2_48khz_hr.onnx` for 48 kHz)
|
||||
|
||||
Example source: [speech-enhancement-dpdfnet-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/speech-enhancement-dpdfnet-c-api.c)
|
||||
|
||||
@section se_online_gtcrn Online GTCRN
|
||||
|
||||
@code
|
||||
SherpaOnnxOnlineSpeechDenoiserConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.gtcrn.model = "./gtcrn_simple.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOnlineSpeechDenoiser *sd =
|
||||
SherpaOnnxCreateOnlineSpeechDenoiser(&config);
|
||||
|
||||
int32_t frame_shift =
|
||||
SherpaOnnxOnlineSpeechDenoiserGetFrameShiftInSamples(sd);
|
||||
// Feed audio in frame_shift chunks, then flush
|
||||
const SherpaOnnxDenoisedAudio *out = SherpaOnnxOnlineSpeechDenoiserFlush(sd);
|
||||
SherpaOnnxDestroyDenoisedAudio(out);
|
||||
SherpaOnnxDestroyOnlineSpeechDenoiser(sd);
|
||||
@endcode
|
||||
|
||||
Model file: `gtcrn_simple.onnx`
|
||||
|
||||
Example source: [online-speech-enhancement-gtcrn-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/online-speech-enhancement-gtcrn-c-api.c)
|
||||
|
||||
@section se_online_dpdfnet Online DPDFNet
|
||||
|
||||
@code
|
||||
SherpaOnnxOnlineSpeechDenoiserConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.dpdfnet.model = "./dpdfnet_baseline.onnx";
|
||||
config.model.num_threads = 1;
|
||||
config.model.provider = "cpu";
|
||||
|
||||
const SherpaOnnxOnlineSpeechDenoiser *sd =
|
||||
SherpaOnnxCreateOnlineSpeechDenoiser(&config);
|
||||
// ... use sd ...
|
||||
SherpaOnnxDestroyOnlineSpeechDenoiser(sd);
|
||||
@endcode
|
||||
|
||||
Model file: `dpdfnet_baseline.onnx`
|
||||
|
||||
Example source: [online-speech-enhancement-dpdfnet-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/online-speech-enhancement-dpdfnet-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,39 @@
|
||||
/**
|
||||
@page spoken_language_id Spoken Language Identification
|
||||
|
||||
sherpa-onnx supports spoken language identification through the
|
||||
@ref SherpaOnnxCreateSpokenLanguageIdentification() API. It uses
|
||||
Whisper-based models to detect the language of spoken audio.
|
||||
|
||||
@see SherpaOnnxCreateSpokenLanguageIdentification,
|
||||
SherpaOnnxSpokenLanguageIdentificationConfig
|
||||
|
||||
@code
|
||||
SherpaOnnxSpokenLanguageIdentificationConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.whisper.encoder = "./sherpa-onnx-whisper-tiny/tiny-encoder.int8.onnx";
|
||||
config.whisper.decoder = "./sherpa-onnx-whisper-tiny/tiny-decoder.int8.onnx";
|
||||
config.num_threads = 1;
|
||||
config.provider = "cpu";
|
||||
|
||||
const SherpaOnnxSpokenLanguageIdentification *slid =
|
||||
SherpaOnnxCreateSpokenLanguageIdentification(&config);
|
||||
|
||||
SherpaOnnxOfflineStream *stream =
|
||||
SherpaOnnxSpokenLanguageIdentificationCreateOfflineStream(slid);
|
||||
SherpaOnnxAcceptWaveformOffline(stream, wave->sample_rate,
|
||||
wave->samples, wave->num_samples);
|
||||
|
||||
const SherpaOnnxSpokenLanguageIdentificationResult *result =
|
||||
SherpaOnnxSpokenLanguageIdentificationCompute(slid, stream);
|
||||
printf("Detected language: %s\n", result->lang);
|
||||
|
||||
SherpaOnnxDestroySpokenLanguageIdentificationResult(result);
|
||||
SherpaOnnxDestroyOfflineStream(stream);
|
||||
SherpaOnnxDestroySpokenLanguageIdentification(slid);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-whisper-tiny`
|
||||
|
||||
Example source: [spoken-language-identification-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/spoken-language-identification-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,196 @@
|
||||
/**
|
||||
@page tts Text-to-Speech (TTS) Models
|
||||
|
||||
sherpa-onnx supports multiple offline TTS model families through the
|
||||
@ref SherpaOnnxCreateOfflineTts() API. Configure exactly one model
|
||||
family by filling in the corresponding sub-struct of
|
||||
@ref SherpaOnnxOfflineTtsModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateOfflineTts, SherpaOnnxOfflineTtsConfig,
|
||||
SherpaOnnxOfflineTtsModelConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section tts_kokoro Kokoro
|
||||
|
||||
Kokoro is a high-quality TTS model with multiple voice support.
|
||||
It uses a model file and a voices binary file.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.kokoro.model = "./kokoro-en-v0_19/model.onnx";
|
||||
config.model.kokoro.voices = "./kokoro-en-v0_19/voices.bin";
|
||||
config.model.kokoro.tokens = "./kokoro-en-v0_19/tokens.txt";
|
||||
config.model.kokoro.data_dir = "./kokoro-en-v0_19/espeak-ng-data";
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `kokoro-en-v0_19` (English), `kokoro-multi-lang-v1_0` (multilingual)
|
||||
|
||||
Example source: [kokoro-tts-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/kokoro-tts-en-c-api.c)
|
||||
|
||||
@section tts_vits VITS (Piper)
|
||||
|
||||
VITS models from the Piper project use espeak-ng for phonemization.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.vits.model =
|
||||
"./vits-piper-en_US-lessac-medium/en_US-lessac-medium.onnx";
|
||||
config.model.vits.tokens =
|
||||
"./vits-piper-en_US-lessac-medium/tokens.txt";
|
||||
config.model.vits.data_dir =
|
||||
"./vits-piper-en_US-lessac-medium/espeak-ng-data";
|
||||
config.model.vits.noise_scale = 0.667f;
|
||||
config.model.vits.noise_scale_w = 0.8f;
|
||||
config.model.vits.length_scale = 1.0f;
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `vits-piper-en_US-lessac-medium`
|
||||
|
||||
Example source: [offline-tts-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/offline-tts-c-api.c)
|
||||
|
||||
@section tts_matcha Matcha
|
||||
|
||||
Matcha is a flow-matching TTS model that requires a separate vocoder
|
||||
(e.g., Vocos).
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.matcha.acoustic_model =
|
||||
"./matcha-icefall-en_US-ljspeech/model-steps-3.onnx";
|
||||
config.model.matcha.vocoder = "./vocos-22khz-univ.onnx";
|
||||
config.model.matcha.tokens =
|
||||
"./matcha-icefall-en_US-ljspeech/tokens.txt";
|
||||
config.model.matcha.data_dir =
|
||||
"./matcha-icefall-en_US-ljspeech/espeak-ng-data";
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `matcha-icefall-en_US-ljspeech` (English),
|
||||
`matcha-icefall-zh-baker` (Chinese)
|
||||
|
||||
Example source: [matcha-tts-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/matcha-tts-en-c-api.c)
|
||||
|
||||
@section tts_kitten Kitten
|
||||
|
||||
Kitten is a compact TTS model with voice support.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.kitten.model = "./kitten-nano-en-v0_1-fp16/model.fp16.onnx";
|
||||
config.model.kitten.voices = "./kitten-nano-en-v0_1-fp16/voices.bin";
|
||||
config.model.kitten.tokens = "./kitten-nano-en-v0_1-fp16/tokens.txt";
|
||||
config.model.kitten.data_dir =
|
||||
"./kitten-nano-en-v0_1-fp16/espeak-ng-data";
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `kitten-nano-en-v0_1-fp16`
|
||||
|
||||
Example source: [kitten-tts-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/kitten-tts-en-c-api.c)
|
||||
|
||||
@section tts_zipvoice ZipVoice
|
||||
|
||||
ZipVoice is a flow-matching TTS model with a separate vocoder. It supports
|
||||
Chinese and English.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.zipvoice.encoder =
|
||||
"./sherpa-onnx-zipvoice-distill-int8-zh-en-emilia/encoder.int8.onnx";
|
||||
config.model.zipvoice.decoder =
|
||||
"./sherpa-onnx-zipvoice-distill-int8-zh-en-emilia/decoder.int8.onnx";
|
||||
config.model.zipvoice.vocoder = "./vocos_24khz.onnx";
|
||||
config.model.zipvoice.tokens =
|
||||
"./sherpa-onnx-zipvoice-distill-int8-zh-en-emilia/tokens.txt";
|
||||
config.model.zipvoice.lexicon =
|
||||
"./sherpa-onnx-zipvoice-distill-int8-zh-en-emilia/lexicon.txt";
|
||||
config.model.zipvoice.data_dir =
|
||||
"./sherpa-onnx-zipvoice-distill-int8-zh-en-emilia/espeak-ng-data";
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-zipvoice-distill-int8-zh-en-emilia`
|
||||
|
||||
Example source: [zipvoice-tts-zh-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/zipvoice-tts-zh-en-c-api.c)
|
||||
|
||||
@section tts_pocket Pocket
|
||||
|
||||
Pocket TTS uses a language model flow architecture with multiple ONNX
|
||||
files.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.pocket.lm_flow =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/lm_flow.int8.onnx";
|
||||
config.model.pocket.lm_main =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/lm_main.int8.onnx";
|
||||
config.model.pocket.encoder =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/encoder.onnx";
|
||||
config.model.pocket.decoder =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/decoder.int8.onnx";
|
||||
config.model.pocket.text_conditioner =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/text_conditioner.onnx";
|
||||
config.model.pocket.vocab_json =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/vocab.json";
|
||||
config.model.pocket.token_scores_json =
|
||||
"./sherpa-onnx-pocket-tts-int8-2026-01-26/token_scores.json";
|
||||
config.model.pocket.voice_embedding_cache_capacity = 50;
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-pocket-tts-int8-2026-01-26`
|
||||
|
||||
Example source: [pocket-tts-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/pocket-tts-en-c-api.c)
|
||||
|
||||
@section tts_supertonic Supertonic
|
||||
|
||||
Supertonic is a non-autoregressive TTS model using duration prediction
|
||||
and vector estimation.
|
||||
|
||||
@code
|
||||
SherpaOnnxOfflineTtsConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.model.supertonic.duration_predictor =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/duration_predictor.int8.onnx";
|
||||
config.model.supertonic.text_encoder =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/text_encoder.int8.onnx";
|
||||
config.model.supertonic.vector_estimator =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/vector_estimator.int8.onnx";
|
||||
config.model.supertonic.vocoder =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/vocoder.int8.onnx";
|
||||
config.model.supertonic.tts_json =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/tts.json";
|
||||
config.model.supertonic.unicode_indexer =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/unicode_indexer.bin";
|
||||
config.model.supertonic.voice_style =
|
||||
"./sherpa-onnx-supertonic-3-tts-int8-2026-05-11/voice.bin";
|
||||
config.model.num_threads = 2;
|
||||
|
||||
const SherpaOnnxOfflineTts *tts = SherpaOnnxCreateOfflineTts(&config);
|
||||
@endcode
|
||||
|
||||
Model package: `sherpa-onnx-supertonic-3-tts-int8-2026-05-11`
|
||||
|
||||
Example source: [supertonic-tts-en-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/supertonic-tts-en-c-api.c)
|
||||
*/
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
@page vad Voice Activity Detection (VAD)
|
||||
|
||||
sherpa-onnx supports two VAD model families through the
|
||||
@ref SherpaOnnxCreateVoiceActivityDetector() API. Configure exactly one
|
||||
by filling in the corresponding field of @ref SherpaOnnxVadModelConfig.
|
||||
|
||||
@see SherpaOnnxCreateVoiceActivityDetector, SherpaOnnxVadModelConfig
|
||||
|
||||
@tableofcontents
|
||||
|
||||
@section vad_silero Silero VAD
|
||||
|
||||
Silero VAD is a widely used voice activity detection model.
|
||||
The recommended window size is 512 samples.
|
||||
|
||||
@code
|
||||
SherpaOnnxVadModelConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.silero_vad.model = "./silero_vad.onnx";
|
||||
config.silero_vad.threshold = 0.25f;
|
||||
config.silero_vad.min_silence_duration = 0.5f;
|
||||
config.silero_vad.min_speech_duration = 0.5f;
|
||||
config.silero_vad.max_speech_duration = 10.0f;
|
||||
config.silero_vad.window_size = 512;
|
||||
config.sample_rate = 16000;
|
||||
config.num_threads = 1;
|
||||
|
||||
const SherpaOnnxVoiceActivityDetector *vad =
|
||||
SherpaOnnxCreateVoiceActivityDetector(&config, 30.0f);
|
||||
@endcode
|
||||
|
||||
Model file: `silero_vad.onnx`
|
||||
|
||||
Example source: [vad-whisper-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/vad-whisper-c-api.c)
|
||||
|
||||
@section vad_ten Ten VAD
|
||||
|
||||
Ten VAD is an alternative VAD model. The recommended window size is 256
|
||||
samples.
|
||||
|
||||
@code
|
||||
SherpaOnnxVadModelConfig config;
|
||||
memset(&config, 0, sizeof(config));
|
||||
config.ten_vad.model = "./ten-vad.onnx";
|
||||
config.ten_vad.threshold = 0.25f;
|
||||
config.ten_vad.min_silence_duration = 0.5f;
|
||||
config.ten_vad.min_speech_duration = 0.5f;
|
||||
config.ten_vad.max_speech_duration = 10.0f;
|
||||
config.ten_vad.window_size = 256;
|
||||
config.sample_rate = 16000;
|
||||
config.num_threads = 1;
|
||||
|
||||
const SherpaOnnxVoiceActivityDetector *vad =
|
||||
SherpaOnnxCreateVoiceActivityDetector(&config, 30.0f);
|
||||
@endcode
|
||||
|
||||
Model file: `ten-vad.onnx`
|
||||
|
||||
Example source: [vad-whisper-c-api.c](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/vad-whisper-c-api.c)
|
||||
*/
|
||||
@@ -25,6 +25,24 @@ The generated docs include the public APIs for:
|
||||
- offline speaker diarization
|
||||
- offline and online speech enhancement
|
||||
|
||||
## Model-specific documentation
|
||||
|
||||
Each model family has its own documentation page with config examples:
|
||||
|
||||
- @ref offline_asr — Non-streaming ASR: Zipformer Transducer, Zipformer CTC, Whisper, SenseVoice, Paraformer, Moonshine, FireRedAsr, Dolphin, Canary, Cohere, WeNet, Omnilingual, FunASR Nano, Qwen3, MedASR, TeleSpeech, GigaAM v2, Parakeet TDT, NeMo CTC
|
||||
- @ref online_asr — Streaming ASR: Transducer (Zipformer), Nemotron, Paraformer, Zipformer2 CTC, T-One CTC
|
||||
- @ref tts — Text-to-Speech: Kokoro, VITS (Piper), Matcha, Kitten, ZipVoice, Pocket, Supertonic
|
||||
- @ref vad — Voice Activity Detection: Silero VAD, Ten VAD
|
||||
- @ref audio_tagging — Audio Tagging: Zipformer, CED
|
||||
- @ref punctuation — Punctuation: Offline (CT-Transformer), Online (CNN-BiLSTM)
|
||||
- @ref speech_enhancement — Speech Enhancement: GTCRN, DPDFNet (offline and online)
|
||||
- @ref source_separation — Source Separation: Spleeter, UVR
|
||||
- @ref speaker_diarization — Speaker Diarization: Pyannote segmentation + embedding clustering
|
||||
- @ref speaker_embedding — Speaker Embedding: extraction, enrollment, search, verification
|
||||
- @ref spoken_language_id — Spoken Language Identification: Whisper-based
|
||||
- @ref keyword_spotting — Keyword Spotting: Zipformer KWS
|
||||
- @ref resampler — Linear Resampler
|
||||
|
||||
The C API also includes HarmonyOS-specific constructor variants where
|
||||
applicable.
|
||||
|
||||
@@ -87,15 +105,47 @@ Representative example programs live in:
|
||||
|
||||
Useful examples include:
|
||||
|
||||
- [`decode-file-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/decode-file-c-api.c)
|
||||
**Offline ASR (C API):**
|
||||
- [`whisper-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/whisper-c-api.c)
|
||||
- [`cohere-transcribe-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/cohere-transcribe-c-api.c)
|
||||
- [`sense-voice-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/sense-voice-c-api.c)
|
||||
- [`paraformer-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/paraformer-c-api.c)
|
||||
- [`moonshine-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/moonshine-c-api.c)
|
||||
- [`zipformer-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/zipformer-c-api.c)
|
||||
- [`nemo-parakeet-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-parakeet-c-api.c)
|
||||
- [`streaming-zipformer-with-hr-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/streaming-zipformer-with-hr-cxx-api.cc)
|
||||
- [`sense-voice-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/sense-voice-cxx-api.cc)
|
||||
- [`nemo-giga-am-v2-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-giga-am-v2-c-api.c)
|
||||
- [`nemo-ctc-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/nemo-ctc-c-api.c)
|
||||
- [`cohere-transcribe-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/cohere-transcribe-c-api.c)
|
||||
- [`dolphin-ctc-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/dolphin-ctc-c-api.c)
|
||||
|
||||
**Streaming ASR (C API):**
|
||||
- [`streaming-zipformer-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-zipformer-c-api.c)
|
||||
- [`streaming-nemotron-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-nemotron-c-api.c)
|
||||
- [`streaming-paraformer-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/streaming-paraformer-c-api.c)
|
||||
|
||||
**TTS (C API):**
|
||||
- [`kokoro-tts-en-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/kokoro-tts-en-c-api.c)
|
||||
- [`pocket-tts-en-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/pocket-tts-en-c-api.c)
|
||||
- [`offline-tts-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/offline-tts-c-api.c)
|
||||
|
||||
**Other features (C API):**
|
||||
- [`vad-whisper-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/vad-whisper-c-api.c)
|
||||
- [`audio-tagging-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/audio-tagging-c-api.c)
|
||||
- [`speaker-identification-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/speaker-identification-c-api.c)
|
||||
- [`offline-speaker-diarization-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/offline-speaker-diarization-c-api.c)
|
||||
- [`spoken-language-identification-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/spoken-language-identification-c-api.c)
|
||||
- [`kws-c-api.c`](https://github.com/k2-fsa/sherpa-onnx/blob/master/c-api-examples/kws-c-api.c)
|
||||
|
||||
**C++ API examples:**
|
||||
- [`streaming-zipformer-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/streaming-zipformer-cxx-api.cc)
|
||||
- [`streaming-nemotron-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/streaming-nemotron-cxx-api.cc)
|
||||
- [`paraformer-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/paraformer-cxx-api.cc)
|
||||
- [`nemo-ctc-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/nemo-ctc-cxx-api.cc)
|
||||
- [`offline-tts-piper-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/offline-tts-piper-cxx-api.cc)
|
||||
- [`pocket-tts-en-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/pocket-tts-en-cxx-api.cc)
|
||||
- [`vad-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/vad-cxx-api.cc)
|
||||
- [`offline-speaker-diarization-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/offline-speaker-diarization-cxx-api.cc)
|
||||
- [`speaker-identification-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/speaker-identification-cxx-api.cc)
|
||||
- [`spoken-language-identification-cxx-api.cc`](https://github.com/k2-fsa/sherpa-onnx/blob/master/cxx-api-examples/spoken-language-identification-cxx-api.cc)
|
||||
|
||||
## Generating the documentation
|
||||
|
||||
|
||||
@@ -26,9 +26,9 @@ _SherpaOnnxCreateOfflineSpeechDenoiser
|
||||
_SherpaOnnxCreateOfflineStream
|
||||
_SherpaOnnxCreateOfflineStreamWithHotwords
|
||||
_SherpaOnnxCreateOfflineTts
|
||||
_SherpaOnnxCreateOnlineSpeechDenoiser
|
||||
_SherpaOnnxCreateOnlinePunctuation
|
||||
_SherpaOnnxCreateOnlineRecognizer
|
||||
_SherpaOnnxCreateOnlineSpeechDenoiser
|
||||
_SherpaOnnxCreateOnlineStream
|
||||
_SherpaOnnxCreateOnlineStreamWithHotwords
|
||||
_SherpaOnnxCreateSpeakerEmbeddingExtractor
|
||||
@@ -51,23 +51,23 @@ _SherpaOnnxDestroyLinearResampler
|
||||
_SherpaOnnxDestroyOfflinePunctuation
|
||||
_SherpaOnnxDestroyOfflineRecognizer
|
||||
_SherpaOnnxDestroyOfflineRecognizerResult
|
||||
_SherpaOnnxDestroyOfflineSpeakerDiarization
|
||||
_SherpaOnnxDestroyOfflineSourceSeparation
|
||||
_SherpaOnnxDestroyOfflineSpeakerDiarization
|
||||
_SherpaOnnxDestroyOfflineSpeechDenoiser
|
||||
_SherpaOnnxDestroyOfflineStream
|
||||
_SherpaOnnxDestroyOfflineStreamResultJson
|
||||
_SherpaOnnxDestroyOfflineTts
|
||||
_SherpaOnnxDestroyOfflineTtsGeneratedAudio
|
||||
_SherpaOnnxDestroyOnlineSpeechDenoiser
|
||||
_SherpaOnnxDestroyOnlinePunctuation
|
||||
_SherpaOnnxDestroyOnlineRecognizer
|
||||
_SherpaOnnxDestroyOnlineRecognizerResult
|
||||
_SherpaOnnxDestroyOnlineSpeechDenoiser
|
||||
_SherpaOnnxDestroyOnlineStream
|
||||
_SherpaOnnxDestroyOnlineStreamResultJson
|
||||
_SherpaOnnxDestroySourceSeparationOutput
|
||||
_SherpaOnnxDestroySpeakerEmbeddingExtractor
|
||||
_SherpaOnnxDestroySpeakerEmbeddingManager
|
||||
_SherpaOnnxDestroySpeechSegment
|
||||
_SherpaOnnxDestroySourceSeparationOutput
|
||||
_SherpaOnnxDestroySpokenLanguageIdentification
|
||||
_SherpaOnnxDestroySpokenLanguageIdentificationResult
|
||||
_SherpaOnnxDestroyVoiceActivityDetector
|
||||
@@ -92,9 +92,9 @@ _SherpaOnnxLinearResamplerResampleGetInputSampleRate
|
||||
_SherpaOnnxLinearResamplerResampleGetOutputSampleRate
|
||||
_SherpaOnnxLinearResamplerReset
|
||||
_SherpaOnnxOfflineRecognizerSetConfig
|
||||
_SherpaOnnxOfflineStreamGetOption
|
||||
_SherpaOnnxOfflineStreamHasOption
|
||||
_SherpaOnnxOfflineStreamSetOption
|
||||
_SherpaOnnxOfflineSourceSeparationGetNumberOfStems
|
||||
_SherpaOnnxOfflineSourceSeparationGetOutputSampleRate
|
||||
_SherpaOnnxOfflineSourceSeparationProcess
|
||||
_SherpaOnnxOfflineSpeakerDiarizationDestroyResult
|
||||
_SherpaOnnxOfflineSpeakerDiarizationDestroySegment
|
||||
_SherpaOnnxOfflineSpeakerDiarizationGetSampleRate
|
||||
@@ -107,9 +107,9 @@ _SherpaOnnxOfflineSpeakerDiarizationResultSortByStartTime
|
||||
_SherpaOnnxOfflineSpeakerDiarizationSetConfig
|
||||
_SherpaOnnxOfflineSpeechDenoiserGetSampleRate
|
||||
_SherpaOnnxOfflineSpeechDenoiserRun
|
||||
_SherpaOnnxOfflineSourceSeparationGetNumberOfStems
|
||||
_SherpaOnnxOfflineSourceSeparationGetOutputSampleRate
|
||||
_SherpaOnnxOfflineSourceSeparationProcess
|
||||
_SherpaOnnxOfflineStreamGetOption
|
||||
_SherpaOnnxOfflineStreamHasOption
|
||||
_SherpaOnnxOfflineStreamSetOption
|
||||
_SherpaOnnxOfflineTtsGenerate
|
||||
_SherpaOnnxOfflineTtsGenerateWithCallback
|
||||
_SherpaOnnxOfflineTtsGenerateWithCallbackWithArg
|
||||
@@ -130,9 +130,9 @@ _SherpaOnnxOnlineStreamAcceptWaveform
|
||||
_SherpaOnnxOnlineStreamGetOption
|
||||
_SherpaOnnxOnlineStreamHasOption
|
||||
_SherpaOnnxOnlineStreamInputFinished
|
||||
_SherpaOnnxOnlineStreamSetOption
|
||||
_SherpaOnnxOnlineStreamIsEndpoint
|
||||
_SherpaOnnxOnlineStreamReset
|
||||
_SherpaOnnxOnlineStreamSetOption
|
||||
_SherpaOnnxPrint
|
||||
_SherpaOnnxReadWave
|
||||
_SherpaOnnxReadWaveFromBinaryData
|
||||
|
||||
Reference in new issue
Block a user