audio_processor_traits/audio_buffer/
mod.rs

1// Augmented Audio: Audio libraries and applications
2// Copyright (c) 2022 Pedro Tacla Yamada
3//
4// The MIT License (MIT)
5//
6// Permission is hereby granted, free of charge, to any person obtaining a copy
7// of this software and associated documentation files (the "Software"), to deal
8// in the Software without restriction, including without limitation the rights
9// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10// copies of the Software, and to permit persons to whom the Software is
11// furnished to do so, subject to the following conditions:
12//
13// The above copyright notice and this permission notice shall be included in
14// all copies or substantial portions of the Software.
15//
16// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22// THE SOFTWARE.
23
24use std::ops::{AddAssign, Div};
25
26use num::Zero;
27
28// pub use audio_buffer_trait::*;
29// pub use interleaved_buffers::*;
30// pub use owned_audio_buffer_trait::*;
31pub use util::*;
32
33// mod audio_buffer_trait;
34// mod interleaved_buffers;
35// mod owned_audio_buffer_trait;
36mod util;
37
38#[derive(Debug, Clone, Default, PartialEq, PartialOrd, Ord, Eq)]
39pub struct AudioBuffer<SampleType> {
40    channels: Vec<Vec<SampleType>>,
41}
42
43impl<SampleType: Clone + Default> AudioBuffer<SampleType> {
44    pub fn from_interleaved(channels: usize, samples: &[SampleType]) -> Self {
45        let mut buffers = vec![vec![SampleType::default(); samples.len() / channels]; channels];
46        copy_from_interleaved(samples, buffers.as_mut_slice());
47
48        Self::new(buffers)
49    }
50
51    pub fn copy_from_interleaved(&mut self, source: &[SampleType]) {
52        copy_from_interleaved(source, &mut self.channels);
53    }
54
55    pub fn copy_into_interleaved(&self, target: &mut [SampleType]) {
56        copy_into_interleaved(&self.channels, target);
57    }
58}
59
60impl<SampleType: Copy + num::Zero> AudioBuffer<SampleType> {
61    pub fn copy_from(&mut self, source: &Self) {
62        for (target, source) in self.channels.iter_mut().zip(source.channels.iter()) {
63            target.copy_from_slice(source);
64        }
65    }
66}
67
68impl<SampleType: Clone> AudioBuffer<SampleType> {
69    pub fn resize_with(
70        &mut self,
71        channels: usize,
72        samples: usize,
73        mut value: impl FnMut() -> SampleType,
74    ) {
75        self.channels
76            .resize_with(channels, || vec![value(); samples]);
77    }
78}
79
80impl<SampleType: num::Zero + Clone> AudioBuffer<SampleType> {
81    pub fn resize(&mut self, channels: usize, samples: usize) {
82        if self.num_channels() != channels {
83            self.channels
84                .resize_with(channels, || vec![SampleType::zero(); samples]);
85        }
86
87        if self.num_samples() != samples {
88            for channel in &mut self.channels {
89                channel.resize(samples, SampleType::zero());
90            }
91        }
92    }
93}
94
95impl<SampleType> AudioBuffer<SampleType> {
96    pub fn new(channels: Vec<Vec<SampleType>>) -> Self {
97        Self { channels }
98    }
99
100    pub fn empty() -> Self {
101        Self::new(vec![])
102    }
103
104    pub fn channel(&self, channel: usize) -> &[SampleType] {
105        &self.channels[channel]
106    }
107
108    pub fn channel_mut(&mut self, channel: usize) -> &mut [SampleType] {
109        &mut self.channels[channel]
110    }
111
112    pub fn channels(&self) -> &Vec<Vec<SampleType>> {
113        &self.channels
114    }
115
116    pub fn channels_mut(&mut self) -> &mut Vec<Vec<SampleType>> {
117        &mut self.channels
118    }
119
120    pub fn slice_mut(&mut self) -> impl Iterator<Item = &mut SampleType> {
121        self.channels.iter_mut().flat_map(|c| c.iter_mut())
122    }
123
124    pub fn num_channels(&self) -> usize {
125        self.channels.len()
126    }
127
128    pub fn num_samples(&self) -> usize {
129        if self.channels.is_empty() {
130            0
131        } else {
132            self.channels[0].len()
133        }
134    }
135
136    pub fn get(&self, channel: usize, sample: usize) -> &SampleType {
137        &self.channels[channel][sample]
138    }
139
140    pub fn get_mut(&mut self, channel: usize, sample: usize) -> &mut SampleType {
141        &mut self.channels[channel][sample]
142    }
143
144    pub fn set(&mut self, channel: usize, sample: usize, value: SampleType) {
145        self.channels[channel][sample] = value;
146    }
147
148    pub fn is_empty(&self) -> bool {
149        self.channels.is_empty() || self.channels[0].is_empty()
150    }
151}
152
153impl<SampleType: Copy + Zero + Div<Output = SampleType> + AddAssign + From<f32>>
154    AudioBuffer<SampleType>
155{
156    pub fn get_mono(&self, sample: usize) -> SampleType {
157        let mut sum = SampleType::zero();
158        for channel in &self.channels {
159            sum += channel[sample];
160        }
161        sum / SampleType::from(self.channels.len() as f32)
162    }
163}
164
165impl<SampleType: Clone + AddAssign> AudioBuffer<SampleType> {
166    pub fn add(&mut self, other: &Self) {
167        for (channel, other_channel) in self.channels.iter_mut().zip(other.channels.iter()) {
168            for (sample, other_sample) in channel.iter_mut().zip(other_channel.iter()) {
169                *sample += other_sample.clone();
170            }
171        }
172    }
173}
174
175impl<SampleType, I, J> From<I> for AudioBuffer<SampleType>
176where
177    I: Iterator<Item = J>,
178    Vec<SampleType>: From<J>,
179{
180    fn from(value: I) -> Self {
181        AudioBuffer::new(value.map(Vec::from).collect())
182    }
183}
184
185#[cfg(feature = "vst")]
186pub mod vst;
187
188/// Copy from an interleaved buffer into a target non-interleaved buffer.
189pub fn copy_from_interleaved<SampleType: Clone>(
190    source: &[SampleType],
191    target: &mut [Vec<SampleType>],
192) {
193    if target.is_empty() {
194        return;
195    }
196
197    let num_channels = target.len();
198    for (sample_idx, frame) in source.chunks(num_channels).enumerate() {
199        for (channel_idx, sample) in frame.iter().enumerate() {
200            target[channel_idx][sample_idx] = sample.clone();
201        }
202    }
203}
204
205pub fn copy_into_interleaved<SampleType: Clone>(
206    source: &[Vec<SampleType>],
207    target: &mut [SampleType],
208) {
209    if source.is_empty() {
210        return;
211    }
212
213    let num_channels = source.len();
214    for (sample_idx, frame) in target.chunks_mut(num_channels).enumerate() {
215        for (channel_idx, sample) in frame.iter_mut().enumerate() {
216            *sample = source[channel_idx][sample_idx].clone();
217        }
218    }
219}
220
221pub fn to_interleaved<SampleType: Copy + num::Zero>(
222    source: &[SampleType],
223    num_channels: usize,
224) -> Vec<Vec<SampleType>> {
225    let mut result = vec![vec![SampleType::zero(); source.len() / num_channels]; num_channels];
226    copy_from_interleaved(source, &mut result);
227    result
228}
229
230#[cfg(test)]
231mod test {
232    use super::*;
233
234    #[test]
235    fn test_from_interleaved() {
236        let source = vec![1.0, 2.0, 3.0, 4.0];
237        let target = AudioBuffer::from_interleaved(2, &source);
238        assert_eq!(target.channels, vec![vec![1.0, 3.0], vec![2.0, 4.0]]);
239    }
240
241    #[test]
242    fn test_audio_buffer_copy_from_interleaved() {
243        let source = vec![1.0, 2.0, 3.0, 4.0];
244        let mut target = AudioBuffer::empty();
245        target.resize(2, 2);
246        target.copy_from_interleaved(&source);
247    }
248
249    #[test]
250    fn test_audio_buffer_copy_into_interleaved() {
251        let source = vec![vec![1.0, 3.0], vec![2.0, 4.0]];
252        let buffer = AudioBuffer::new(source);
253
254        let mut target = vec![0.0; 4];
255        buffer.copy_into_interleaved(&mut target);
256        assert_eq!(target, vec![1.0, 2.0, 3.0, 4.0]);
257    }
258
259    #[test]
260    fn test_copy_from_interleaved_empty() {
261        let mut target: Vec<Vec<f32>> = vec![vec![0.0; 0]; 0];
262        let source = vec![];
263        copy_from_interleaved(&source, &mut target);
264        assert_eq!(target, Vec::<Vec<f32>>::new());
265    }
266
267    #[test]
268    fn test_copy_from_interleaved() {
269        let mut target: Vec<Vec<f32>> = vec![vec![0.0; 2]; 2];
270        let source = vec![1.0, 2.0, 3.0, 4.0];
271        copy_from_interleaved(&source, &mut target);
272        assert_eq!(target, vec![vec![1.0, 3.0], vec![2.0, 4.0]]);
273    }
274
275    #[test]
276    fn test_to_interleaved() {
277        let source = vec![1.0, 2.0, 3.0, 4.0];
278        let result = to_interleaved(&source, 2);
279        assert_eq!(result, vec![vec![1.0, 3.0], vec![2.0, 4.0]]);
280    }
281
282    #[test]
283    fn test_copy_into_interleaved() {
284        let source = vec![vec![1.0, 3.0], vec![2.0, 4.0]];
285        let mut target = vec![0.0, 0.0, 0.0, 0.0];
286        copy_into_interleaved(&source, &mut target);
287        assert_eq!(target, vec![1.0, 2.0, 3.0, 4.0]);
288    }
289}
audio_processor_traits/audio_buffer/mod.rs

audio_processor_traits/audio_buffer/
mod.rs
