# Expected Audio Chunk Size and Sample Rate for Meetily: A Technical Deep Dive

> Discover Meetily's audio chunk size and sample rate. Learn how Meetily captures and processes audio at 48 kHz and 16 kHz for efficient transcription and VAD.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-20

---

**Meetily captures audio at 48 kHz in 100 ms chunks containing approximately 4,800 samples, then resamples to 16 kHz (yielding ~1,600 samples) for Whisper transcription and VAD processing.**

Zackriya-Solutions/meetily is an open-source meeting transcription tool built on a Rust-based audio pipeline. Understanding the expected audio chunk size and sample rate for Meetily is critical for developers maintaining the capture modules, extending voice activity detection, or debugging audio synchronization issues across the system.

## Capture Configuration: 48 kHz Sample Rate

The audio input pipeline in Meetily hard-codes both microphone and system audio capture at **48,000 Hz**. This sample rate is established during stream initialization in [`frontend/src-tauri/src/audio/stream.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/stream.rs), where the configuration uses `config.sample_rate().0` to set the hardware capture parameters【/frontend/src-tauri/src/audio/stream.rs†L118-L124】.

### Fixed 100 ms Chunk Duration

Meetily processes audio in fixed-duration segments defined by the `CHUNK_DURATION_MS` constant, set to **100 milliseconds**. This duration serves as the atomic processing unit throughout the mixing, VAD, and buffering modules.

### Calculating Chunk Size in Samples

The chunk size in samples is computed using the formula found in [`frontend/src-tauri/src/lib_old_complex.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib_old_complex.rs):

```rust
chunk_samples = (sample_rate * CHUNK_DURATION_MS) / 1000

```

With the 48 kHz capture rate, this calculation yields approximately **4,800 samples per chunk**【/frontend/src-tauri/src/lib_old_complex.rs†L294-L298】.

## Transcription Pipeline: 16 kHz Resampling

Before audio reaches the Whisper transcription engine, Meetily resamples the stream from 48 kHz to **16,000 Hz**, which is the required input format for OpenAI's Whisper models. This resampling logic is implemented in [`frontend/src-tauri/src/audio/transcription/worker.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/transcription/worker.rs)【L414-L416】.

When processed at 16 kHz, the same 100 ms chunk duration contains **approximately 1,600 samples** (16,000 Hz × 0.1 seconds).

### Voice Activity Detection (VAD) Configuration

The VAD module also expects 16 kHz audio, as defined by the `VAD_SAMPLE_RATE` constant in [`frontend/src-tauri/src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs)【L20-L38】. This alignment eliminates the need for additional resampling between voice detection and transcription stages.

## Implementation Code Examples

The following Rust excerpts demonstrate the core audio processing logic used throughout the Meetily codebase:

**Calculating capture chunk size:**

```rust
// From frontend/src-tauri/src/lib_old_complex.rs
let chunk_samples = (sample_rate as f32 * (CHUNK_DURATION_MS as f32 / 1000.0)) as usize;
// Yields 4,800 samples at 48 kHz with 100 ms chunks

```

**Resampling for Whisper transcription:**

```rust
// From frontend/src-tauri/src/audio/transcription/worker.rs
let whisper_samples = if chunk.sample_rate != 16_000 {
    crate::audio::audio_processing::resample_audio(&chunk.data, chunk.sample_rate, 16_000)
} else {
    chunk.data.clone()
};

```

## Summary

- Meetily captures microphone and system audio at **48,000 Hz** according to the stream configuration in [`frontend/src-tauri/src/audio/stream.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/stream.rs).
- Audio is processed in **100 ms chunks**, resulting in approximately **4,800 samples** at the capture stage.
- Before transcription, audio is **resampled to 16,000 Hz**, reducing each chunk to roughly **1,600 samples**.
- Both VAD and Whisper transcription modules expect the 16 kHz sample rate as implemented in [`audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/vad.rs) and [`audio/transcription/worker.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/transcription/worker.rs).

## Frequently Asked Questions

### What sample rate does Meetily use for microphone capture?

Meetily captures microphone and system audio at **48,000 Hz**. This is hard-coded in the audio stream initialization within [`frontend/src-tauri/src/audio/stream.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/stream.rs) where the sample rate configuration is applied to the input device through the `config.sample_rate()` method.

### How many samples are in each audio chunk processed by Meetily?

At the capture stage, each 100 ms chunk contains approximately **4,800 samples** (calculated as 48,000 Hz × 0.1 seconds). After resampling for transcription, each chunk contains approximately **1,600 samples** at 16,000 Hz.

### Why does Meetily resample audio from 48 kHz to 16 kHz?

Meetily resamples to **16 kHz** because OpenAI's Whisper speech recognition models and the Voice Activity Detection (VAD) engine both require 16 kHz input. The resampling occurs in [`frontend/src-tauri/src/audio/transcription/worker.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/transcription/worker.rs) before sending audio to the transcription worker to ensure compatibility with these downstream components.

### Can I modify the chunk duration in Meetily's source code?

While the `CHUNK_DURATION_MS` constant in [`frontend/src-tauri/src/lib_old_complex.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib_old_complex.rs) controls the chunk timing, changing this value from the default **100 ms** would require updates to downstream processing logic in the VAD and transcription modules to maintain synchronization across the audio pipeline.