babycat 0.0.15

An audio decoding and manipulation library, with bindings for C, Python, and WebAssembly.
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
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

//! This module is not really part of Babycat's pubic API, but is made public
//! to make benchmarking Babycat internals easier.
//!
//! If you want to use Babycat to resample audio, you should decode
//! the audio into a [`Waveform`][crate::Waveform]
//! and then use the [`Waveform.resample()`][crate::Waveform#method.resample] method.

use crate::backend::{
    errors::Error,
    resample::common::{get_num_output_frames, validate_args},
};

#[allow(clippy::excessive_precision)]
#[allow(clippy::unreadable_literal)]
const KAISER_BEST_WINDOW: [f32; 32769] = include!("kaiser_best.txt");

#[allow(clippy::cast_possible_truncation)]
#[allow(clippy::cast_sign_loss)]
#[allow(clippy::cast_precision_loss)]
pub fn resample(
    input_frame_rate_hz: u32,
    output_frame_rate_hz: u32,
    num_channels: u16,
    input_audio: &[f32],
) -> Result<Vec<f32>, Error> {
    validate_args(input_frame_rate_hz, output_frame_rate_hz, num_channels)?;

    let sample_ratio: f32 =
        (f64::from(output_frame_rate_hz) / f64::from(input_frame_rate_hz as f32)) as f32;

    let num_output_frames = get_num_output_frames(
        input_audio,
        input_frame_rate_hz,
        output_frame_rate_hz,
        num_channels,
    );
    let ret_size = num_output_frames * (num_channels as usize);
    let mut ret: Vec<f32> = vec![0.0_f32; ret_size];

    let mut interp_win = KAISER_BEST_WINDOW;
    let precision = 512;
    if sample_ratio < 1.0 {
        for i in interp_win.iter_mut() {
            *i *= sample_ratio;
        }
    }

    // Same length as interp_win
    let interp_delta = interp_win
        .windows(2)
        .map(|w| w[1] - w[0])
        .chain(Some(0.0))
        .collect::<Vec<_>>();

    resample_f(
        input_audio,
        &mut ret,
        num_channels as usize,
        f64::from(output_frame_rate_hz) / f64::from(input_frame_rate_hz),
        &interp_win,
        &interp_delta,
        precision,
    );

    Ok(ret)
}

#[allow(clippy::cast_possible_truncation)]
#[allow(clippy::cast_sign_loss)]
#[allow(clippy::cast_precision_loss)]
fn resample_f(
    in_audio: &[f32],
    out_audio: &mut [f32],
    num_channels: usize,
    sample_ratio: f64,
    interp_win: &[f32],
    interp_delta: &[f32],
    num_table: i32,
) {
    let scale = std::primitive::f64::min(sample_ratio, 1.0);

    // equal to (in_audio_hz / out_audio_hz)
    let time_increment = 1.0 / sample_ratio;
    let index_step = (scale * f64::from(num_table)) as usize;

    let n_win = interp_win.len();
    let n_in_frames = in_audio.len() / (num_channels);
    let n_out_frames = out_audio.len() / (num_channels);

    for out_frame_idx in 0..n_out_frames {
        let time_register = time_increment * out_frame_idx as f64;
        let in_frame_idx = time_register as usize;

        let frac: f64 = scale * time_register.fract();
        let index_frac = frac * f64::from(num_table);
        let offset = index_frac as usize;
        let eta = index_frac.fract() as f32;

        let i_max = std::cmp::min(in_frame_idx + 1, (n_win - offset) / index_step);
        for i in 0..i_max {
            let weight =
                interp_win[offset + i * index_step] + eta * interp_delta[offset + i * index_step];
            for channel_idx in 0..num_channels {
                let out_idx: usize = (out_frame_idx * num_channels) + channel_idx;
                let in_idx: usize = ((in_frame_idx - i) * num_channels) + channel_idx;
                out_audio[out_idx] += weight * in_audio[in_idx];
            }
        }

        // Right wing of response
        let frac = scale - frac;
        let index_frac = frac * f64::from(num_table);
        let offset = index_frac as usize;
        let eta = index_frac.fract() as f32;

        let k_max = std::cmp::min(
            n_in_frames - in_frame_idx - 1,
            (n_win - offset) / index_step,
        );
        for k in 0..k_max {
            let weight =
                interp_win[offset + k * index_step] + eta * interp_delta[offset + k * index_step];
            for channel_idx in 0..num_channels {
                let out_idx: usize = (out_frame_idx * num_channels) + channel_idx;
                let in_idx: usize = ((in_frame_idx + k + 1) * num_channels) + channel_idx;
                out_audio[out_idx] += weight * in_audio[in_idx];
            }
        }
    }
}