1use aura_params::sample::Sample;
4
5pub 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 #[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 #[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 #[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 #[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 #[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}