rubato 2.0.0

Asynchronous resampling library intended for audio data
Documentation 
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

use crate::windows::{make_window, WindowFunction};
use crate::Sample;

/// Helper function: sinc(x) = sin(pi*x)/(pi*x).
pub fn sinc<T>(value: T) -> T
where
    T: Sample,
{
    if value == T::zero() {
        T::one()
    } else {
        (value * T::PI).sin() / (value * T::PI)
    }
}

/// Helper function. Make a set of windowed sincs.
pub fn make_sincs<T>(
    npoints: usize,
    factor: usize,
    f_cutoff: f32,
    windowfunc: WindowFunction,
) -> Vec<Vec<T>>
where
    T: Sample,
{
    let totpoints = npoints * factor;
    let mut y = Vec::with_capacity(totpoints);
    let window = make_window::<T>(totpoints, windowfunc);
    let mut sum = T::zero();
    for (x, w) in window.iter().enumerate().take(totpoints) {
        let val = *w
            * sinc(
                (T::coerce(x) - T::coerce(totpoints / 2)) * T::coerce(f_cutoff) / T::coerce(factor),
            );
        sum += val;
        y.push(val);
    }
    sum /= T::coerce(factor);
    debug!(
        "Generate sincs, length: {}, oversampling: {}, normalized by: {:?}",
        npoints, factor, sum
    );
    let mut sincs = vec![vec![T::zero(); npoints]; factor];
    for p in 0..npoints {
        for n in 0..factor {
            sincs[factor - n - 1][p] = y[factor * p + n] / sum;
        }
    }
    sincs
}

#[cfg(test)]
mod tests {
    use crate::sinc::make_sincs;
    use crate::WindowFunction;
    use test_log::test;

    #[test]
    fn sincs() {
        let sincs = make_sincs::<f64>(32, 8, 0.9, WindowFunction::Blackman);
        assert!((sincs[7][16] - 1.0).abs() < 0.2);
        let sum: f64 = sincs.iter().map(|v| v.iter().sum::<f64>()).sum();
        assert!((sum - 8.0).abs() < 0.00001);
    }
}