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

//! Базовые процессоры для тестирования и отладки

use crate::engine::AudioProcessor;

/// Процессор, пропускающий входной сигнал без изменений
pub struct PassThroughProcessor;

impl AudioProcessor for PassThroughProcessor {
    fn process(&mut self, input: &[f32], output: &mut [f32]) {
        output.copy_from_slice(input);
    }

    fn reset(&mut self) {}

    fn set_sample_rate(&mut self, _sample_rate: f32) {}
}

/// Процессор, генерирующий тишину (все нули)
pub struct SilenceProcessor;

impl AudioProcessor for SilenceProcessor {
    fn process(&mut self, _input: &[f32], output: &mut [f32]) {
        output.fill(0.0);
    }

    fn reset(&mut self) {}

    fn set_sample_rate(&mut self, _sample_rate: f32) {}
}

/// Процессор, усиливающий сигнал с заданным коэффициентом
pub struct GainProcessor {
    gain: f32,
}

impl GainProcessor {
    /// Создать новый процессор с коэффициентом усиления
    pub fn new(gain: f32) -> Self {
        Self {
            gain: gain.max(0.0),
        }
    }

    /// Установить коэффициент усиления
    pub fn set_gain(&mut self, gain: f32) {
        self.gain = gain.max(0.0);
    }
}

impl AudioProcessor for GainProcessor {
    fn process(&mut self, input: &[f32], output: &mut [f32]) {
        for (i, sample) in input.iter().enumerate() {
            if i < output.len() {
                output[i] = sample * self.gain;
            }
        }
    }

    fn reset(&mut self) {}

    fn set_sample_rate(&mut self, _sample_rate: f32) {}
}

/// Процессор, смешивающий два канала в моно
pub struct MonoMixerProcessor;

impl AudioProcessor for MonoMixerProcessor {
    fn process(&mut self, input: &[f32], output: &mut [f32]) {
        let stereo_samples = input.len() / 2;
        for i in 0..stereo_samples.min(output.len()) {
            output[i] = (input[i * 2] + input[i * 2 + 1]) * 0.5;
        }
    }

    fn reset(&mut self) {}

    fn set_sample_rate(&mut self, _sample_rate: f32) {}
}

/// Процессор, записывающий входной сигнал в кольцевой буфер (для отладки)
#[cfg(feature = "examples")]
pub struct CaptureProcessor {
    buffer: Vec<f32>,
    position: usize,
}

#[cfg(feature = "examples")]
impl CaptureProcessor {
    pub fn new(capacity: usize) -> Self {
        Self {
            buffer: vec![0.0; capacity],
            position: 0,
        }
    }

    pub fn get_buffer(&self) -> &[f32] {
        &self.buffer
    }
}

#[cfg(feature = "examples")]
impl AudioProcessor for CaptureProcessor {
    fn process(&mut self, input: &[f32], output: &mut [f32]) {
        // Просто копируем вход в выход
        output.copy_from_slice(input);

        // И записываем в буфер
        for sample in input {
            self.buffer[self.position] = *sample;
            self.position = (self.position + 1) % self.buffer.len();
        }
    }

    fn reset(&mut self) {
        self.buffer.fill(0.0);
        self.position = 0;
    }

    fn set_sample_rate(&mut self, _sample_rate: f32) {}
}