rustwav_lib/
utils.rs

1#![allow(dead_code)]
2
3use std::{any::TypeId, borrow::Cow, slice};
4
5use crate::AudioWriteError;
6use crate::SampleType;
7use crate::Resampler;
8
9pub fn stereos_to_dual_monos<S>(stereos: &[(S, S)]) -> (Vec<S>, Vec<S>)
10where S: SampleType {
11    let l = stereos.iter().map(|(l, _r): &(S, S)| -> S {*l}).collect();
12    let r = stereos.iter().map(|(_l, r): &(S, S)| -> S {*r}).collect();
13    (l, r)
14}
15
16pub fn is_same_len<S>(data: &[Vec<S>]) -> Option<(bool, usize)> {
17    if data.is_empty() {
18        None
19    } else {
20        let lengths: Vec<usize> = data.iter().map(|item| item.len()).collect();
21        let first = lengths[0];
22        Some((lengths.iter().all(|&item| item == first), first))
23    }
24}
25
26pub fn frames_to_stereos<S>(frames: &[Vec<S>]) -> Result<Vec<(S, S)>, AudioWriteError>
27where S: SampleType {
28    match is_same_len(frames) {
29        None => Ok(Vec::<(S, S)>::new()),
30        Some((equal, channels)) => {
31            match equal {
32                false => Err(AudioWriteError::FrameChannelsNotSame),
33                true => {
34                    match channels {
35                        1 => Ok(frames.iter().map(|frame: &Vec<S>| -> (S, S) {(frame[0], frame[0])}).collect()),
36                        2 => Ok(frames.iter().map(|frame: &Vec<S>| -> (S, S) {(frame[0], frame[1])}).collect()),
37                        o => Err(AudioWriteError::WrongChannels(format!("{o}"))),
38                    }
39                }
40            }
41        }
42    }
43}
44
45pub fn frames_to_dual_mono<S>(frames: &[Vec<S>]) -> Result<(Vec<S>, Vec<S>), AudioWriteError>
46where S: SampleType {
47    Ok(stereos_to_dual_monos(&frames_to_stereos(frames)?))
48}
49
50pub fn frames_to_monos<S>(frames: &[Vec<S>], channels: Option<u16>) -> Result<Vec<Vec<S>>, AudioWriteError>
51where S: SampleType {
52    match is_same_len(frames) {
53        None => Ok(Vec::<Vec<S>>::new()),
54        Some((equal, length)) => {
55            match equal {
56                false => Err(AudioWriteError::FrameChannelsNotSame),
57                true => {
58                    if let Some(channels) = channels {
59                        if channels as usize != length {
60                            return Err(AudioWriteError::WrongChannels(format!("The channels is {channels} but the frames are {length} channels")));
61                        }
62                    }
63                    Ok((0..length).map(|channel| -> Vec<S> {frames.iter().map(|frame: &Vec<S>| -> S {frame[channel]}).collect()}).collect())
64                }
65            }
66        }
67    }
68}
69
70pub fn monos_to_frames<S>(monos: &[Vec<S>]) -> Result<Vec<Vec<S>>, AudioWriteError>
71where S: SampleType {
72    match is_same_len(monos) {
73        None => Ok(Vec::<Vec<S>>::new()),
74        Some((equal, length)) => {
75            match equal {
76                false => Err(AudioWriteError::MultipleMonosAreNotSameSize),
77                true => {
78                    Ok((0..length).map(|position: usize| -> Vec<S> {monos.iter().map(|channel: &Vec<S>| -> S {channel[position]}).collect()}).collect())
79                }
80            }
81        }
82    }
83}
84
85pub fn monos_to_interleaved_samples<S>(monos: &[Vec<S>]) -> Result<Vec<S>, AudioWriteError>
86where S: SampleType {
87    Ok(monos_to_frames(monos)?.into_iter().flatten().collect())
88}
89
90pub fn frames_to_interleaved_samples<S>(frames: &[Vec<S>], channels: Option<u16>) -> Result<Vec<S>, AudioWriteError>
91where S: SampleType {
92    monos_to_interleaved_samples(&frames_to_monos(frames, channels)?)
93}
94
95pub fn stereos_to_interleaved_samples<S>(stereos: &[(S, S)]) -> Vec<S>
96where S: SampleType {
97    stereos.iter().flat_map(|(l, r): &(S, S)| -> [S; 2] {[*l, *r]}).collect()
98}
99
100pub fn interleaved_samples_to_monos<S>(samples: &[S], channels: u16) -> Result<Vec<Vec<S>>, AudioWriteError>
101where S: SampleType {
102    if channels == 0 {
103        Err(AudioWriteError::InvalidArguments("Channels must not be zero".to_owned()))
104    } else {
105        Ok((0..channels).map(|channel| -> Vec<S> {samples.iter().skip(channel as usize).step_by(channels as usize).copied().collect()}).collect())
106    }
107}
108
109pub fn dual_monos_to_stereos<S>(dual_monos: &(Vec<S>, Vec<S>)) -> Result<Vec<(S, S)>, AudioWriteError>
110where S: SampleType {
111    let (l, r) = dual_monos;
112    if l.len() != r.len() {
113        Err(AudioWriteError::MultipleMonosAreNotSameSize)
114    } else {
115        Ok(l.iter().zip(r).map(|(l, r): (&S, &S)| -> (S, S) {(*l, *r)}).collect())
116    }
117}
118
119pub fn interleaved_samples_to_stereos<S>(samples: &[S]) -> Result<Vec<(S, S)>, AudioWriteError>
120where S: SampleType {
121    if (samples.len() & 1) != 0 {
122        Err(AudioWriteError::NotStereo)
123    } else {
124        Ok((0..(samples.len() / 2)).map(|position| -> (S, S) {(samples[position * 2], samples[position * 2 + 1])}).collect())
125    }
126}
127
128pub fn dual_monos_to_monos<S>(dual_monos: &(Vec<S>, Vec<S>)) -> Result<Vec<S>, AudioWriteError>
129where S: SampleType {
130    let (l, r) = dual_monos;
131    if l.len() != r.len() {
132        Err(AudioWriteError::MultipleMonosAreNotSameSize)
133    } else {
134        Ok(l.iter().zip(r).map(|(l, r): (&S, &S)| -> S {S::average(*l, *r)}).collect())
135    }
136}
137
138pub fn monos_to_dual_monos<S>(monos: &[S]) -> (Vec<S>, Vec<S>)
139where S: SampleType {
140    (monos.to_vec(), monos.to_vec())
141}
142
143pub fn stereos_to_monos<S>(stereos: &[(S, S)]) -> Vec<S>
144where S: SampleType {
145    stereos.iter().map(|(l, r): &(S, S)| -> S {S::average(*l, *r)}).collect()
146}
147
148pub fn monos_to_stereos<S>(monos: &[S]) -> Vec<(S, S)>
149where S: SampleType {
150    monos.iter().map(|s|{(*s, *s)}).collect()
151}
152
153// 样本类型缩放转换
154// 根据样本的存储值范围大小的不同，进行缩放使适应目标样本类型。
155#[inline(always)]
156pub fn stereo_conv<S, D>(frame: (S, S)) -> (D, D)
157where S: SampleType,
158      D: SampleType {
159    let (l, r) = frame;
160    (D::from(l), D::from(r))
161}
162
163pub fn sample_conv<'a, S, D>(frame: &'a [S]) -> Cow<'a, [D]>
164where S: SampleType,
165      D: SampleType {
166
167    if TypeId::of::<S>() == TypeId::of::<D>() {
168        Cow::Borrowed(unsafe{slice::from_raw_parts(frame.as_ptr() as *const D, frame.len())})
169    } else {
170        Cow::Owned(frame.iter().map(|sample: &S| -> D {D::from(*sample)}).collect())
171    }
172}
173
174pub fn stereos_conv<'a, S, D>(stereos: &'a [(S, S)]) -> Cow<'a, [(D, D)]>
175where S: SampleType,
176      D: SampleType {
177
178    if TypeId::of::<S>() == TypeId::of::<D>() {
179        Cow::Borrowed(unsafe{slice::from_raw_parts(stereos.as_ptr() as *const (D, D), stereos.len())})
180    } else {
181        Cow::Owned(stereos.iter().map(|stereo: &(S, S)| -> (D, D) {stereo_conv(*stereo)}).collect())
182    }
183}
184
185// 样本类型缩放转换批量版
186pub fn sample_conv_batch<'a, S, D>(frames: &[Vec<S>]) ->  Cow<'a, [Vec<D>]>
187where S: SampleType,
188      D: SampleType {
189
190    if TypeId::of::<S>() == TypeId::of::<D>() {
191        Cow::Borrowed(unsafe{slice::from_raw_parts(frames.as_ptr() as *const Vec<D>, frames.len())})
192    } else {
193        Cow::Owned(frames.iter().map(|frames: &Vec<S>| -> Vec<D> {sample_conv(frames).to_vec()}).collect())
194    }
195}
196
197pub fn do_resample_mono<S>(resampler: &Resampler, input: &[S], src_sample_rate: u32, dst_sample_rate: u32) -> Vec<S>
198where S: SampleType {
199    let input = sample_conv::<S, f32>(input);
200    let result = resampler.resample(&input, src_sample_rate, dst_sample_rate).unwrap();
201    sample_conv::<f32, S>(&result).to_vec()
202}
203
204pub fn do_resample_stereo<S>(resampler: &Resampler, input: &[(S, S)], src_sample_rate: u32, dst_sample_rate: u32) -> Vec<(S, S)>
205where S: SampleType {
206    let block = stereos_to_dual_monos(input);
207    let l = do_resample_mono(resampler, &block.0, src_sample_rate, dst_sample_rate);
208    let r = do_resample_mono(resampler, &block.1, src_sample_rate, dst_sample_rate);
209    dual_monos_to_stereos(&(l, r)).unwrap()
210}
211
212pub fn do_resample_frames<S>(resampler: &Resampler, input: &[Vec<S>], src_sample_rate: u32, dst_sample_rate: u32) -> Vec<Vec<S>>
213where S: SampleType {
214    let monos = frames_to_monos(input, None).unwrap();
215    let monos: Vec<Vec<S>> = monos.into_iter().map(|mono|{do_resample_mono(resampler, &mono, src_sample_rate, dst_sample_rate)}).collect();
216    monos_to_frames(&monos).unwrap()
217}
rustwav_lib/utils.rs

rustwav_lib/
utils.rs
