Add Rust API for VAD

.github/scripts/test-rust.sh

@@ -6,6 +6,8 @@ cd rust-api-examples
 
 ./run-version.sh
 
+./run-silero-vad-remove-silence.sh
+
 ./run-nemo-parakeet-en.sh
 ./run-zipformer-vi.sh
 ./run-zipformer-zh-en.sh

rust-api-examples/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "rust-api-examples"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 
 [dependencies]
 anyhow = "1.0"
 clap = { version = "4.5", features = ["derive"] }
-sherpa-onnx = "0.1.6"
+sherpa-onnx = "0.1.7"
 # sherpa-onnx = { path = "../sherpa-onnx/rust/sherpa-onnx" }
 
 cpal = { version = "0.16", optional = true } # cross-platform audio I/O

rust-api-examples/README.md

@@ -92,6 +92,19 @@ cargo run --example sense_voice -- \
     --tokens ./sherpa-onnx-sense-voice-zh-en-ja-ko-yue-int8-2024-07-17/tokens.txt
 ```
 
+### Example 5: Remove silences from a file using SileroVAD
+
+```bash
+
+curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx
+curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/lei-jun-test.wav
+
+cargo run --example silero_vad_remove_silence -- \
+    --input ./lei-jun-test.wav \
+    --output ./no-silence.wav \
+    --silero-vad-model ./silero_vad.onnx
+```
+
 # Alternative rust bindings for sherpa-onnx
 
 Please see also https://github.com/thewh1teagle/sherpa-rs

rust-api-examples/examples/silero_vad_remove_silence.rs

@@ -0,0 +1,109 @@
+// Copyright (c) 2026 Xiaomi Corporation
+//
+// This file demonstrates how to use silero VAD with sherpa-onnx's
+// Rust API to remove non-speech segments and save speech-only audio.
+//
+// See ../README.md for how to run it
+
+use clap::Parser;
+use sherpa_onnx::{self, SileroVadModelConfig, VadModelConfig, VoiceActivityDetector, Wave};
+
+/// Simple VAD example: remove non-speech segments from a WAV file
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// Path to input WAV file
+    #[arg(long)]
+    input: String,
+
+    /// Path to output WAV file
+    #[arg(long)]
+    output: String,
+
+    /// Path to Silero VAD ONNX model
+    #[arg(long)]
+    silero_vad_model: String,
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = Args::parse();
+
+    // Read WAV file
+    let wave = Wave::read(&args.input)
+        .ok_or_else(|| anyhow::anyhow!("Failed to read WAV file: {}", &args.input))?;
+    let sample_rate = wave.sample_rate();
+    let input_num_samples = wave.num_samples();
+    let input_duration = input_num_samples as f32 / sample_rate as f32;
+
+    println!(
+        "Input WAV: sample rate: {}, num samples: {}, duration: {:.2}s",
+        sample_rate, input_num_samples, input_duration
+    );
+
+    // Configure VAD
+    let mut silero_config = SileroVadModelConfig::default();
+    silero_config.model = Some(args.silero_vad_model);
+
+    // You can tune the values below
+    silero_config.threshold = 0.5;
+    silero_config.min_silence_duration = 0.25;
+    silero_config.min_speech_duration = 0.25;
+    silero_config.max_speech_duration = 5.0;
+
+    let vad_config = VadModelConfig {
+        silero_vad: silero_config,
+        ten_vad: Default::default(),
+        sample_rate,
+        num_threads: 1,
+        provider: Some("cpu".to_string()),
+        debug: false,
+    };
+
+    let vad = VoiceActivityDetector::create(&vad_config, 30.0)
+        .expect("Failed to create VoiceActivityDetector");
+
+    let mut speech_samples = Vec::new();
+    const WINDOW_SIZE: usize = 512;
+
+    for chunk in wave.samples().chunks(WINDOW_SIZE) {
+        vad.accept_waveform(chunk);
+
+        while let Some(seg) = vad.front() {
+            speech_samples.extend_from_slice(seg.samples());
+            vad.pop();
+        }
+    }
+
+    vad.flush();
+    while let Some(seg) = vad.front() {
+        speech_samples.extend_from_slice(seg.samples());
+        vad.pop();
+    }
+
+    // Write speech-only samples to output WAV
+    let ok = sherpa_onnx::write(&args.output, &speech_samples, sample_rate);
+    if ok {
+        println!("Saved speech-only audio to {}", args.output);
+    } else {
+        println!("Failed to save speech-only audio to {}", args.output);
+    }
+
+    // Summary
+    let output_num_samples = speech_samples.len();
+    let output_duration = output_num_samples as f32 / sample_rate as f32;
+    println!("\n=== Summary ===");
+    println!(
+        "Input:  sample rate = {}, samples = {}, duration = {:.2}s",
+        sample_rate, input_num_samples, input_duration
+    );
+    println!(
+        "Output: sample rate = {}, samples = {}, duration = {:.2}s",
+        sample_rate, output_num_samples, output_duration
+    );
+    println!(
+        "Removed non-speech: {:.2}% of input removed",
+        100.0 * (1.0 - output_duration / input_duration)
+    );
+
+    Ok(())
+}

rust-api-examples/run-silero-vad-remove-silence.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -ex
+
+# https://k2-fsa.github.io/sherpa/onnx/vad/silero-vad.html
+if [ ! -f "./silero_vad.onnx" ]; then
+  curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx
+fi
+
+if [ ! -f ./lei-jun-test.wav ]; then
+  curl -SL -O https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/lei-jun-test.wav
+fi
+
+cargo run --example silero_vad_remove_silence -- \
+    --input ./lei-jun-test.wav \
+    --output ./no-silence.wav \
+    --silero-vad-model ./silero_vad.onnx

sherpa-onnx/c-api/c-api.cc

@@ -1128,7 +1128,7 @@ struct SherpaOnnxVoiceActivityDetector {
   std::unique_ptr<sherpa_onnx::VoiceActivityDetector> impl;
 };
 
-sherpa_onnx::VadModelConfig GetVadModelConfig(
+static sherpa_onnx::VadModelConfig GetVadModelConfig(
     const SherpaOnnxVadModelConfig *config) {
   sherpa_onnx::VadModelConfig vad_config;
 
@@ -1185,6 +1185,11 @@ sherpa_onnx::VadModelConfig GetVadModelConfig(
 
 const SherpaOnnxVoiceActivityDetector *SherpaOnnxCreateVoiceActivityDetector(
     const SherpaOnnxVadModelConfig *config, float buffer_size_in_seconds) {
+  if (!config) {
+    SHERPA_ONNX_LOGE("vad config is nullptr");
+    return nullptr;
+  }
+
   auto vad_config = GetVadModelConfig(config);
 
   if (!vad_config.Validate()) {
@@ -1206,31 +1211,70 @@ void SherpaOnnxDestroyVoiceActivityDetector(
 
 void SherpaOnnxVoiceActivityDetectorAcceptWaveform(
     const SherpaOnnxVoiceActivityDetector *p, const float *samples, int32_t n) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return;
+  }
+
+  if (!samples) {
+    SHERPA_ONNX_LOGE("samples is nullptr");
+    return;
+  }
+
   p->impl->AcceptWaveform(samples, n);
 }
 
 int32_t SherpaOnnxVoiceActivityDetectorEmpty(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return 1;  // 1 means it is empty
+  }
+
   return p->impl->Empty();
 }
 
 int32_t SherpaOnnxVoiceActivityDetectorDetected(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return 0;
+  }
+
   return p->impl->IsSpeechDetected();
 }
 
 void SherpaOnnxVoiceActivityDetectorPop(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return;
+  }
+
   p->impl->Pop();
 }
 
 void SherpaOnnxVoiceActivityDetectorClear(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return;
+  }
+
   p->impl->Clear();
 }
 
 const SherpaOnnxSpeechSegment *SherpaOnnxVoiceActivityDetectorFront(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return nullptr;
+  }
+
+  if (SherpaOnnxVoiceActivityDetectorEmpty(p)) {
+    return nullptr;
+  }
+
   const sherpa_onnx::SpeechSegment &segment = p->impl->Front();
 
   SherpaOnnxSpeechSegment *ans = new SherpaOnnxSpeechSegment;
@@ -1251,11 +1295,21 @@ void SherpaOnnxDestroySpeechSegment(const SherpaOnnxSpeechSegment *p) {
 
 void SherpaOnnxVoiceActivityDetectorReset(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return;
+  }
+
   p->impl->Reset();
 }
 
 void SherpaOnnxVoiceActivityDetectorFlush(
     const SherpaOnnxVoiceActivityDetector *p) {
+  if (!p) {
+    SHERPA_ONNX_LOGE("vad is nullptr");
+    return;
+  }
+
   p->impl->Flush();
 }
 

sherpa-onnx/csrc/voice-activity-detector.cc

@@ -141,7 +141,18 @@ class VoiceActivityDetector::Impl {
 
   void Clear() { std::queue<SpeechSegment>().swap(segments_); }
 
-  const SpeechSegment &Front() const { return segments_.front(); }
+  const SpeechSegment &Front() const {
+    static SpeechSegment tmp;
+
+    if (Empty()) {
+      SHERPA_ONNX_LOGE(
+          "Make sure you call this method only when Empty() returns false; "
+          "Return an empty segment");
+      return tmp;
+    }
+
+    return segments_.front();
+  }
 
   void Reset() {
     std::queue<SpeechSegment>().swap(segments_);

sherpa-onnx/rust/sherpa-onnx-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sherpa-onnx-sys"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 description = "Raw FFI bindings to the sherpa-onnx C API"
 license = "Apache-2.0"

sherpa-onnx/rust/sherpa-onnx-sys/src/lib.rs

@@ -13,8 +13,10 @@ extern "C" {
 
 pub mod offline_asr;
 pub mod online_asr;
+pub mod vad;
 pub mod wave;
 
 pub use offline_asr::*;
 pub use online_asr::*;
+pub use vad::*;
 pub use wave::*;