skadoosh 0.4.0

Modular, low-latency local voice agent framework: VAD → Whisper STT → streaming LLM → ONNX TTS with barge-in
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Audio I/O: cpal capture/playback plus a zero-dependency resampler.
//!
//! Capture converts device-rate input to 16 kHz mono and pushes it into a
//! lock-free ring buffer; playback pops 24 kHz [`crate::tts::TtsClip`]s and
//! resamples to the device rate. Real-time callbacks never allocate or lock.

pub mod aec;
pub mod input;
pub mod output;
pub mod resample;

pub use input::{list_devices, push_block_drop_count, AudioInputConfig, MicCapture, CAPTURE_RATE};
pub use output::{
    push_clip_blocking, AudioOutputConfig, OutputPump, Playback, PlaybackHandle, CLIP_SAMPLE_RATE,
};
pub use resample::{resample_offline, LinearResampler};

use cpal::traits::DeviceTrait;

use crate::error::{AudioError, Result};

/// Best-effort device name (cpal 0.18: `DeviceDescription::name()` with a
/// `Display` fallback). Shared by input/output device picking and
/// `--list-devices`.
pub(crate) fn device_name(device: &cpal::Device) -> Option<String> {
    match device.description() {
        Ok(desc) => Some(desc.name().to_string()),
        Err(_) => {
            let name = device.to_string();
            (!name.is_empty()).then_some(name)
        }
    }
}

/// Picks the device named `name` from `devices`, or falls back to `default`
/// when no name is configured. Shared by capture and playback setup.
pub(crate) fn pick_device<I>(
    name: Option<&str>,
    devices: std::result::Result<I, cpal::Error>,
    default: Option<cpal::Device>,
) -> Result<cpal::Device>
where
    I: Iterator<Item = cpal::Device>,
{
    match name {
        Some(name) => Ok(devices
            .map_err(|err| AudioError::StreamConfig(err.to_string()))?
            .find(|dev| device_name(dev).as_deref() == Some(name))
            .ok_or(AudioError::NoDevice)?),
        None => Ok(default.ok_or(AudioError::NoDevice)?),
    }
}

/// Collects a device's supported config ranges. A device that cannot even
/// report configurations is unusable (headless machines commonly list such a
/// phantom ALSA "default" PCM); report it as "no suitable device" (the cause
/// is logged).
pub(crate) fn config_ranges<I>(
    kind: &str,
    configs: std::result::Result<I, cpal::Error>,
) -> Result<Vec<cpal::SupportedStreamConfigRange>>
where
    I: Iterator<Item = cpal::SupportedStreamConfigRange>,
{
    match configs {
        Ok(ranges) => Ok(ranges.collect()),
        Err(err) => {
            tracing::warn!(%err, "{kind} device config query failed; device unusable");
            Err(AudioError::NoDevice.into())
        }
    }
}

/// Picks a supported stream config: prefers f32, then i16, then u16; within
/// a format prefers `preferred_rate` when the range covers it, else the
/// range's maximum sample rate. Any channel count is accepted (the capture
/// callback mixes down to mono; playback duplicates mono across channels).
pub(crate) fn negotiate_config(
    ranges: &[cpal::SupportedStreamConfigRange],
    preferred_rate: u32,
) -> Option<cpal::SupportedStreamConfig> {
    for format in [
        cpal::SampleFormat::F32,
        cpal::SampleFormat::I16,
        cpal::SampleFormat::U16,
    ] {
        let mut fallback = None;
        for range in ranges
            .iter()
            .copied()
            .filter(|r| r.sample_format() == format)
        {
            if let Some(cfg) = range.try_with_sample_rate(preferred_rate) {
                return Some(cfg);
            }
            fallback.get_or_insert_with(|| range.with_max_sample_rate());
        }
        if fallback.is_some() {
            return fallback;
        }
    }
    None
}