Skip to main content

aura_core/
buffer.rs

1//! Non-interleaved audio buffer (minimal).
2
3use aura_params::sample::Sample;
4
5/// Borrowed host channel buffers for one process block.
6///
7/// Channel ordering is `[main inputs] [sidechain inputs]` /
8/// `[main outputs] [aux outputs]`.
9pub struct AudioBuffer<'a, S: Sample = f32> {
10    inputs: &'a [&'a [S]],
11    outputs: &'a mut [&'a mut [S]],
12    num_samples: usize,
13    main_input_count: usize,
14    sidechain_input_count: usize,
15    main_output_count: usize,
16}
17
18impl<'a, S: Sample> AudioBuffer<'a, S> {
19    /// # Safety
20    /// Slices must be valid for `'a`; `num_samples` must not exceed any channel length.
21    /// Treats all `inputs` as main inputs and all `outputs` as main outputs.
22    #[must_use]
23    pub unsafe fn from_slices(
24        inputs: &'a [&'a [S]],
25        outputs: &'a mut [&'a mut [S]],
26        num_samples: usize,
27    ) -> Self {
28        debug_assert!(inputs.iter().all(|c| c.len() >= num_samples));
29        debug_assert!(outputs.iter().all(|c| c.len() >= num_samples));
30        let n_out = outputs.len();
31        Self {
32            inputs,
33            outputs,
34            num_samples,
35            main_input_count: inputs.len(),
36            sidechain_input_count: 0,
37            main_output_count: n_out,
38        }
39    }
40
41    /// Checked variant of [`from_slices`](Self::from_slices).
42    ///
43    /// # Panics
44    /// Panics if any channel has fewer than `num_samples` elements.
45    #[must_use]
46    pub fn from_slices_checked(
47        inputs: &'a [&'a [S]],
48        outputs: &'a mut [&'a mut [S]],
49        num_samples: usize,
50    ) -> Self {
51        assert!(inputs.iter().all(|c| c.len() >= num_samples));
52        assert!(outputs.iter().all(|c| c.len() >= num_samples));
53        unsafe { Self::from_slices(inputs, outputs, num_samples) }
54    }
55
56    /// Build a buffer with separated main + sidechain inputs (all outs = main).
57    ///
58    /// # Panics
59    /// Panics if counts don't match `inputs` / channel lengths.
60    #[must_use]
61    pub fn from_slices_checked_with_sidechain(
62        inputs: &'a [&'a [S]],
63        outputs: &'a mut [&'a mut [S]],
64        num_samples: usize,
65        main_input_count: usize,
66        sidechain_input_count: usize,
67    ) -> Self {
68        assert_eq!(main_input_count + sidechain_input_count, inputs.len());
69        assert!(inputs.iter().all(|c| c.len() >= num_samples));
70        assert!(outputs.iter().all(|c| c.len() >= num_samples));
71        unsafe {
72            Self::from_slices_with_sidechain_unchecked(
73                inputs,
74                outputs,
75                num_samples,
76                main_input_count,
77                sidechain_input_count,
78            )
79        }
80    }
81
82    /// # Safety
83    /// Same as [`from_slices`](Self::from_slices); all outputs count as main.
84    #[must_use]
85    pub unsafe fn from_slices_with_sidechain_unchecked(
86        inputs: &'a [&'a [S]],
87        outputs: &'a mut [&'a mut [S]],
88        num_samples: usize,
89        main_input_count: usize,
90        sidechain_input_count: usize,
91    ) -> Self {
92        let n_out = outputs.len();
93        unsafe {
94            Self::from_slices_with_buses_unchecked(
95                inputs,
96                outputs,
97                num_samples,
98                main_input_count,
99                sidechain_input_count,
100                n_out,
101            )
102        }
103    }
104
105    /// # Safety
106    /// Caller ensures counts match slice lengths; `main_output_count ≤ outputs.len()`.
107    #[must_use]
108    pub unsafe fn from_slices_with_buses_unchecked(
109        inputs: &'a [&'a [S]],
110        outputs: &'a mut [&'a mut [S]],
111        num_samples: usize,
112        main_input_count: usize,
113        sidechain_input_count: usize,
114        main_output_count: usize,
115    ) -> Self {
116        debug_assert!(inputs.iter().all(|c| c.len() >= num_samples));
117        debug_assert!(outputs.iter().all(|c| c.len() >= num_samples));
118        debug_assert!(main_output_count <= outputs.len());
119        Self {
120            inputs,
121            outputs,
122            num_samples,
123            main_input_count,
124            sidechain_input_count,
125            main_output_count,
126        }
127    }
128
129    #[must_use]
130    pub fn num_samples(&self) -> usize {
131        self.num_samples
132    }
133
134    #[must_use]
135    pub fn num_inputs(&self) -> usize {
136        self.inputs.len()
137    }
138
139    #[must_use]
140    pub fn num_main_inputs(&self) -> usize {
141        self.main_input_count
142    }
143
144    #[must_use]
145    pub fn num_sidechain_inputs(&self) -> usize {
146        self.sidechain_input_count
147    }
148
149    #[must_use]
150    pub fn num_outputs(&self) -> usize {
151        self.outputs.len()
152    }
153
154    #[must_use]
155    pub fn num_main_outputs(&self) -> usize {
156        self.main_output_count
157    }
158
159    #[must_use]
160    pub fn num_aux_outputs(&self) -> usize {
161        self.outputs.len().saturating_sub(self.main_output_count)
162    }
163
164    #[must_use]
165    pub fn input(&self, ch: usize) -> &[S] {
166        &self.inputs[ch][..self.num_samples]
167    }
168
169    #[must_use]
170    pub fn main_input(&self, ch: usize) -> &[S] {
171        &self.inputs[ch][..self.num_samples]
172    }
173
174    #[must_use]
175    pub fn sidechain_input(&self, ch: usize) -> &[S] {
176        &self.inputs[self.main_input_count + ch][..self.num_samples]
177    }
178
179    pub fn output(&mut self, ch: usize) -> &mut [S] {
180        &mut self.outputs[ch][..self.num_samples]
181    }
182
183    pub fn main_output(&mut self, ch: usize) -> &mut [S] {
184        &mut self.outputs[ch][..self.num_samples]
185    }
186
187    pub fn aux_output(&mut self, ch: usize) -> &mut [S] {
188        &mut self.outputs[self.main_output_count + ch][..self.num_samples]
189    }
190}