How Meetily Manages Audio Buffers Using Ring Buffers and VecDeque for Windowed Processing

Meetily implements a dual-ring buffer architecture using Rust VecDeque to synchronize asynchronous microphone and system audio streams into fixed 50ms windows, enabling real-time mixing and voice activity detection prior to Whisper transcription.

Meetily is an open-source meeting transcription application developed by Zackriya-Solutions that captures both microphone input and system audio simultaneously. To handle the inherent asynchrony between these two capture sources while maintaining low latency for the Whisper speech-to-text engine, the codebase employs a specialized ring buffer implementation. This article examines how VecDeque structures in frontend/src-tauri/src/audio/pipeline.rs facilitate efficient windowed audio processing.

Core Ring Buffer Architecture

The audio pipeline centers on the AudioMixerRingBuffer struct, which maintains two circular buffers to temporarily store incoming PCM samples from heterogeneous sources.

VecDeque Buffer Structure

As defined in [frontend/src-tauri/src/audio/pipeline.rs](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs#L16-L46), the implementation creates two VecDeque<f32> instances:

• mic_buffer – Stores samples from the user's microphone
• system_buffer – Stores samples from system audio capture

VecDeque provides O(1) amortized complexity for push_back and pop_front operations, making it ideal for sliding-window audio processing. The buffers are initialized with pre-allocated capacity using with_capacity to minimize reallocation during real-time capture.

Window Size and Safety Limits

The ring buffer enforces strict temporal boundaries to prevent latency drift:

• Window size: Fixed at approximately 50ms of audio (window_size_samples), calculated from the device sample rate
• Maximum buffer: Hard-coded to 400ms (max_buffer_size) to prevent memory overflow during jitter or burst conditions

When either buffer exceeds this limit, the oldest samples are automatically dropped using pop_front, and the system logs appropriate warnings via the warn! macro for microphone overflow or error! for system audio overflow.

Processing Flow and Synchronization

The pipeline implements a three-stage processing flow that continuously consumes audio chunks while maintaining stream alignment.

Adding Samples with Flow Control

The add_samples(device_type, samples) method (lines 49-85) handles incoming audio fragments:

1. Appends new samples to the appropriate deque using extend
2. Monitors buffer health through periodic logging
3. Detects overflow conditions and removes stale data from the front of the queue

This design ensures that temporary network delays or processing spikes do not cause unbounded memory growth.

Mixing Conditions

The can_mix() method returns true when either buffer contains at least window_size_samples. This permissive strategy ensures continuous output generation even when one source experiences temporary dropout, preventing pipeline stalls.

Window Extraction and Zero-Padding

When mixing conditions are met, extract_window() pulls exactly window_size_samples from each deque:

• Returns paired Vec<f32> instances for microphone and system audio
• Applies zero-padding to channels that are shorter than the window size, inserting silence to prevent click artifacts
• Enables downstream processing such as RMS-based ducking and professional mixing

Integration with VAD and Whisper

After extraction, the mixed windows are passed to the ContinuousVadProcessor implemented in [frontend/src-tauri/src/audio/vad.rs](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs#L22-L30). This voice activity detection stage filters non-speech frames before they reach the Whisper engine, reducing transcription computational load by approximately 70% while maintaining low end-to-end latency.

Why VecDeque Over Alternatives?

Meetily's choice of VecDeque addresses three specific requirements of real-time audio processing:

Requirement	VecDeque Implementation Benefit
Fast push & pop	O(1) amortized extend and pop_front operations for sliding windows
Memory reuse	Pre-allocated capacity prevents GC pressure and allocation spikes during capture
Zero-copy extraction	drain and slice iterators provide window views without copying entire buffer contents

This architecture avoids the reallocation costs associated with Vec and provides deterministic performance characteristics required for real-time audio pipelines.

Practical Implementation Example

The following Rust code demonstrates initializing the ring buffer and processing audio chunks:

use crate::audio::pipeline::AudioMixerRingBuffer;
use crate::audio::recording_state::DeviceType;

// Initialise a ring buffer for a 48 kHz device
let mut mixer = AudioMixerRingBuffer::new(48_000);

// Simulated incoming microphone chunk (e.g., 10 ms of audio)
let mic_chunk: Vec<f32> = vec![0.0; 480]; // 48 kHz * 0.01 s
mixer.add_samples(DeviceType::Microphone, mic_chunk);

// Simulated system audio chunk
let sys_chunk: Vec<f32> = vec![0.1; 480];
mixer.add_samples(DeviceType::System, sys_chunk);

// Check if we have enough data for a mixing window
if mixer.can_mix() {
    // Pull aligned windows for mixing / VAD
    if let Some((mic_win, sys_win)) = mixer.extract_window() {
        // `mic_win` and `sys_win` are ready for RMS ducking,
        // professional mixing, or VAD processing
        process_mixed_window(mic_win, sys_win);
    }
}

Key Source Files

• frontend/src-tauri/src/audio/pipeline.rs – Contains AudioMixerRingBuffer with VecDeque management, window extraction, and overflow handling
• frontend/src-tauri/src/audio/vad.rs – Implements ContinuousVadProcessor for speech filtering
• frontend/src-tauri/src/audio/buffer_pool.rs – Manages reusable audio buffers using VecDeque for allocation efficiency
• frontend/src-tauri/src/audio/recording_state.rs – Defines DeviceType enum (Microphone/System) used for buffer routing

Summary

• Meetily uses dual VecDeque<f32> ring buffers (mic_buffer and system_buffer) to synchronize asynchronous audio sources with O(1) insertion and removal.
• The 50ms window extraction with zero-padding ensures continuous mixing even when one stream experiences dropout.
• 400ms safety limits prevent memory overflow, automatically dropping oldest samples while logging warnings.
• Integration with ContinuousVadProcessor filters non-speech audio before Whisper transcription, reducing computational load by 70%.
• VecDeque provides predictable memory reuse and zero-copy slice extraction essential for real-time performance.

Frequently Asked Questions

How does Meetily prevent audio desynchronization between microphone and system sources?

Meetily implements a permissive mixing strategy where can_mix() returns true when either buffer reaches the 50ms threshold. If one source lags, extract_window() zero-pads the shorter buffer with silence, ensuring aligned output without pipeline stalls. This design tolerates temporary jitter while maintaining temporal alignment.

Why does the code use VecDeque instead of a standard Vec for audio buffers?

VecDeque provides O(1) amortized operations at both ends, allowing efficient sample removal from the front (oldest data) and addition to the back (newest data). Standard Vec requires O(n) shifting for front removal. Additionally, VecDeque supports pre-allocated capacity and efficient memory reuse, preventing allocation spikes during real-time capture.

What happens when audio capture exceeds the 400ms buffer limit?

When add_samples() detects buffer overflow, it logs a warn! for microphone overflow or error! for system audio overflow, then removes excess samples from the front using pop_front. This hard limit prevents unbounded memory growth during network delays or processing bursts, ensuring the application remains responsive.

How does the ring buffer architecture reduce Whisper transcription costs?

By extracting fixed 50ms windows and passing them through ContinuousVadProcessor before transcription, Meetily filters non-speech frames (silence, background noise) from the audio stream. According to the source implementation, this reduces the transcription engine's computational load by approximately 70%, enabling real-time processing on consumer hardware.

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