Voice Activity Detection (VAD) Role in Meetily's Transcription Pipeline

Voice Activity Detection (VAD) serves as the decisive gatekeeper in Meetily's transcription pipeline, isolating genuine speech from mixed audio streams before delivering clean, validated segments to the Whisper transcription engine.

In the open-source meeting assistant Zackriya-Solutions/meetily, VAD is the architectural cornerstone that determines transcription quality and resource efficiency. By processing dual audio streams through a Silero-based detection algorithm, Meetily ensures that only voice activity—free from silence and background noise—reaches the GPU-intensive Whisper model.

How VAD Integrates into Meetily's Dual-Stream Architecture

Meetily captures audio through two parallel inputs: microphone input (user speech) and system audio (shared screen sound). These streams are mixed into a continuous 48 kHz feed before entering the VAD processor.

The VAD implementation in frontend/src-tauri/src/audio/vad.rs (lines 33–65) handles real-time resampling and segmentation. It converts the incoming 48 kHz mixed signal into 16 kHz chunks of 30 ms duration (480 samples each). This resampling step is critical because the underlying Silero VAD model requires 16 kHz input, while the system otherwise operates at higher fidelity for audio capture.

Once resampled, the audio flows into frontend/src-tauri/src/audio/pipeline.rs (lines 678–735), where the VAD-driven logic replaces traditional time-based chunking. Instead of splitting audio into arbitrary 2-second blocks, the pipeline uses actual voice detection to determine segment boundaries, ensuring that transcription only occurs during active speech.

Three Core Responsibilities of VAD in the Transcription Path

Speech-Only Segmentation and Noise Filtering

The primary function of VAD is to convert continuous audio into discrete speech segments. In frontend/src-tauri/src/audio/pipeline.rs (lines 678–735), the processor analyzes each 30 ms window to classify sound as speech or non-speech. Silence and background noise are aggressively filtered out at this stage.

This segmentation prevents the Whisper engine from attempting to transcribe silent periods, which significantly reduces hallucinations—erroneous text generation when processing noise or dead air. By stripping non-speech audio before transcription, Meetily reduces the data volume sent to Whisper by substantial margins.

Dynamic Chunking Using Redemption Time

Unlike earlier implementations that relied on fixed target_chunk_duration_ms intervals, Meetily's VAD-driven pipeline employs a "redemption time" mechanism. As implemented in frontend/src-tauri/src/audio/pipeline.rs (lines 722–731), the system uses a default 2000 ms redemption window to bridge natural pauses in conversation.

This means that brief silences within a sentence do not trigger premature transcription sends. Instead, VAD maintains the current speech segment across short gaps, producing longer, linguistically coherent chunks that improve Whisper's contextual understanding and transcription accuracy.

Direct Pre-Filtering for the Whisper Engine

Once VAD confirms a speech segment is complete, it dispatches the audio directly to the transcription worker without any additional silence pruning. The pipeline code in frontend/src-tauri/src/audio/pipeline.rs (lines 841–858) logs each segment's precise duration and sample count before calling whisper_engine.transcribe().

This direct handoff guarantees that Whisper receives only validated speech samples, eliminating redundant CPU cycles that would otherwise process silence. The implementation ensures that the whisper_engine operates exclusively on high-quality, speech-only audio buffers.

Implementation Walkthrough: From Raw Audio to Transcription

The VAD processor is instantiated with specific sample rate configurations to handle the mixed audio stream:

let vad = VadProcessor::new(
    input_sample_rate,            // 48 kHz mixed audio from mic + system
    VAD_SAMPLE_RATE,              // 16 kHz required by Silero VAD
    VAD_REDEMPTION_TIME_MS,       // 2000 ms bridges natural pauses
)?;

The pipeline executes the VAD-driven workflow asynchronously, managing the flow from capture to transcription:

info!("VAD-driven audio pipeline started");
pipeline.run_vad().await?;
info!("VAD-driven audio pipeline ended");

When a speech segment is finalized, it is immediately sent to the transcription engine with metadata logging:

info!(
    "📤 Sending VAD segment: {:.1}ms, {} samples",
    segment.duration_ms(),
    segment.sample_count()
);
whisper_engine.transcribe(segment).await?;

Performance Impact and Accuracy Benefits

By positioning VAD as the first processing layer, Meetily achieves significant computational savings. The Whisper model avoids processing silent frames, resulting in lower GPU and CPU utilization during meetings with substantial dead air or pause-heavy dialogue.

Additionally, the VAD-driven approach produces more natural transcript segmentation. Because chunks align with actual speech boundaries rather than arbitrary time slices, Whisper receives complete phrases and sentences, improving recognition accuracy for context-dependent words and technical terminology.

Summary

• VAD acts as a gatekeeper in frontend/src-tauri/src/audio/vad.rs, filtering mixed 48 kHz audio into 16 kHz speech segments before Whisper processing.
• Dynamic redemption time (default 2000 ms) in frontend/src-tauri/src/audio/pipeline.rs bridges natural pauses, creating linguistically coherent chunks instead of arbitrary time slices.
• Pre-filtering eliminates hallucinations by ensuring the transcription engine in frontend/src-tauri/src/audio/transcription/worker.rs receives only validated speech, reducing computational overhead and improving accuracy.
• Silero-based detection processes audio in 30 ms windows (480 samples at 16 kHz), enabling real-time decision-making with minimal latency.

Frequently Asked Questions

What is the primary purpose of VAD in Meetily?

The primary purpose is to isolate genuine speech from mixed audio streams containing silence, background noise, and system sounds. By filtering audio before it reaches the Whisper engine, VAD prevents transcription hallucinations and reduces the computational load on GPU resources.

How does Meetily's VAD handle natural pauses in speech?

Meetily implements a "redemption time" of 2000 ms as configured in frontend/src-tauri/src/audio/pipeline.rs (lines 722–731). This buffer allows the system to maintain speech segmentation across brief silences within sentences, ensuring that natural conversational pauses do not split related phrases into separate transcription chunks.

What audio sample rates does Meetily's VAD processor use?

The system captures mixed audio at 48 kHz but immediately resamples to 16 kHz for VAD processing, as required by the Silero VAD model. The processor analyzes audio in 30 ms chunks containing 480 samples at the 16 kHz rate, as defined in frontend/src-tauri/src/audio/vad.rs (lines 33–65).

Where is the VAD logic implemented in the Meetily codebase?

The core VAD implementation resides in frontend/src-tauri/src/audio/vad.rs, which handles the Silero-based detection and resampling. The integration with the broader audio pipeline occurs in frontend/src-tauri/src/audio/pipeline.rs, while frontend/src-tauri/src/audio/transcription/worker.rs receives the filtered segments for Whisper processing.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}