rill-io 0.3.0

Audio I/O backends for Rill - CPAL, ALSA, PipeWire, JACK
Documentation 
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Audio I/O backends for Rill
//!
//! This crate provides a unified interface to various audio backends
//! using dynamic ring buffers for cross-thread I/O.

#![warn(missing_docs)]

mod backend;
mod buffer;
mod config;
mod engine;
mod error;

pub mod backends;
pub mod processor;

pub use backend::{AudioBackend, BackendType, DeviceInfo};
pub use config::AudioConfig;
pub use engine::{AudioEngine, AudioProcessor, EngineState};
pub use error::{IoError, IoResult};

pub use backends::NullBackend;

#[cfg(feature = "cpal")]
pub use backends::CpalBackend;

#[cfg(feature = "alsa")]
pub use backends::AlsaBackend;

#[cfg(feature = "pipewire")]
pub use backends::PipewireBackend;

#[cfg(feature = "jack")]
pub use backends::JackBackend;

// Processor re-exports
pub use processor::{GainProcessor, MonoMixerProcessor, PassThroughProcessor, SilenceProcessor};

#[cfg(feature = "graph")]
pub use processor::GraphProcessor;

#[cfg(feature = "examples")]
pub use processor::SineProcessor;

#[cfg(feature = "examples")]
pub use processor::CaptureProcessor;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::AudioConfig;
    use crate::processor::{
        GainProcessor, MonoMixerProcessor, PassThroughProcessor, SilenceProcessor,
    };

    #[test]
    fn test_config_default() {
        let config = AudioConfig::default();
        assert_eq!(config.sample_rate, 48000);
        assert_eq!(config.buffer_size, 256);
        assert_eq!(config.input_channels, 2);
        assert_eq!(config.output_channels, 2);
    }

    #[test]
    fn test_config_with_methods() {
        let config = AudioConfig::new()
            .with_sample_rate(44100)
            .with_buffer_size(512)
            .with_channels(1);
        assert_eq!(config.sample_rate, 44100);
        assert_eq!(config.buffer_size, 512);
    }

    #[test]
    fn test_latency_calculation() {
        let config = AudioConfig::new()
            .with_sample_rate(48000)
            .with_buffer_size(256);
        let latency_sec = config.latency_seconds();
        let latency_ms = config.latency_ms();
        assert!((latency_sec - 256.0 / 48000.0).abs() < 1e-10);
        assert!((latency_ms - 256.0 * 1000.0 / 48000.0).abs() < 1e-10);
    }

    #[test]
    fn test_gain_processor() {
        let mut proc = GainProcessor::new(2.0);
        let input = vec![1.0, 2.0, 3.0];
        let mut output = vec![0.0; 3];
        proc.process(&input, &mut output);
        assert_eq!(output, vec![2.0, 4.0, 6.0]);
    }

    #[test]
    fn test_passthrough_processor() {
        let mut proc = PassThroughProcessor;
        let input = vec![1.0, -1.0, 0.5];
        let mut output = vec![0.0; 3];
        proc.process(&input, &mut output);
        assert_eq!(output, input);
    }

    #[test]
    fn test_silence_processor() {
        let mut proc = SilenceProcessor;
        let input = vec![1.0, 2.0, 3.0];
        let mut output = vec![1.0; 3];
        proc.process(&input, &mut output);
        assert_eq!(output, vec![0.0; 3]);
    }

    #[test]
    fn test_mono_mixer_processor() {
        let mut proc = MonoMixerProcessor;
        let input = vec![0.8, 0.2, 0.5, 0.5, 1.0, 0.0];
        let mut output = vec![0.0; 3];
        proc.process(&input, &mut output);
        assert_eq!(output, vec![0.5, 0.5, 0.5]);
    }
}