cpal 0.0.12

Cross-platform audio playing library in pure Rust.
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

/*!
This module contains function that will convert from one PCM format to another.

This includes conversion between samples formats, channels or sample rates.

*/
use samples_formats::Sample;

/// Converts between samples rates while preserving the pitch.
pub fn convert_samples_rate<T>(input: &[T], from: ::SamplesRate, to: ::SamplesRate,
                               channels: ::ChannelsCount) -> Vec<T>
                               where T: Sample
{
    let from = from.0;
    let to = to.0;

    // if `from` is a multiple of `to` (for example `from` is 44100 and `to` is 22050),
    // then we simply skip some samples
    if from % to == 0 {
        let mut result = Vec::new();
        for element in input.chunks(channels as usize * (from / to) as usize) {
            for i in range(0, channels) {
                result.push(element[i as usize]);
            }
        }
        return result;
    }

    // if `to` is twice `from` (for example `to` is 44100 and `from` is 22050)
    // TODO: more generic
    if to == from * 2 {
        let mut result = Vec::new();
        let mut previous: Option<Vec<T>> = None;
        for element in input.chunks(channels as usize) {
            if let Some(previous) = previous.take() {
                for (prev, curr) in previous.into_iter().zip(element.iter()) {
                    result.push(prev.interpolate(*curr));
                }
                for curr in element.iter() {
                    result.push(*curr);
                }
            } else {
                for e in element.iter() {
                    result.push(*e);
                }
            }

            previous = Some(element.to_vec());
        }
        return result;
    }

    unimplemented!()
}

/// Converts between a certain number of channels.
///
/// If the target number is inferior to the source number, additional channels are removed.
///
/// If the target number is superior to the source number, the value of channel `N` is equal
/// to the value of channel `N % source_channels`.
///
/// ## Panic
///
/// Panics if `from` is 0, `to` is 0, or if the data length is not a multiple of `from`.
pub fn convert_channels<T>(input: &[T], from: ::ChannelsCount, to: ::ChannelsCount) -> Vec<T>
                           where T: Sample
{
    assert!(from != 0);
    assert!(to != 0);
    assert!(input.len() % from as usize == 0);

    let mut result = Vec::new();

    for element in input.chunks(from as usize) {
        // copying the common channels
        for i in range(0, ::std::cmp::min(from, to)) {
            result.push(element[i as usize]);
        }

        // adding extra ones
        if to > from {
            for i in range(0, to - from) {
                result.push(element[i as usize % element.len()]);
            }
        }
    }

    result
}

#[cfg(test)]
mod test {
    use super::convert_channels;
    use super::convert_samples_rate;

    #[test]
    fn remove_channels() {
        let result = convert_channels(&[1u16, 2, 3, 1, 2, 3], 3, 2);
        assert_eq!(result.as_slice(), [1, 2, 1, 2]);

        let result = convert_channels(&[1u16, 2, 3, 4, 1, 2, 3, 4], 4, 1);
        assert_eq!(result.as_slice(), [1, 1]);
    }

    #[test]
    fn add_channels() {
        let result = convert_channels(&[1u16, 2, 1, 2], 2, 3);
        assert_eq!(result.as_slice(), [1, 2, 1, 1, 2, 1]);

        let result = convert_channels(&[1u16, 2, 1, 2], 2, 4);
        assert_eq!(result.as_slice(), [1, 2, 1, 2, 1, 2, 1, 2]);
    }

    #[test]
    #[should_fail]
    fn convert_channels_wrong_data_len() {
        convert_channels(&[1u16, 2, 3], 2, 1);
    }

    #[test]
    fn half_samples_rate() {
        let result = convert_samples_rate(&[1u16, 16, 2, 17, 3, 18, 4, 19],
                                          ::SamplesRate(44100), ::SamplesRate(22050), 2);

        assert_eq!(result.as_slice(), [1, 16, 3, 18]);
    }

    #[test]
    fn double_samples_rate() {
        let result = convert_samples_rate(&[2u16, 16, 4, 18, 6, 20, 8, 22],
                                          ::SamplesRate(22050), ::SamplesRate(44100), 2);

        assert_eq!(result.as_slice(), [2, 16, 3, 17, 4, 18, 5, 19, 6, 20, 7, 21, 8, 22]);
    }
}