Skip to main content

qualia_audio/io/resample/
windowed_sinc.rs

1//! Band-limited windowed-sinc (Lanczos) resampler — the quality path.
2//!
3//! Delegated to [`etalon_signal::resample::windowed_sinc_resample_into`].
4
5use crate::types::AudioError;
6
7/// Resample mono f32 `src` (`src_rate`) → `dst_rate` into caller-buffered `out`,
8/// using a Lanczos-windowed-sinc kernel with `half_taps` on each side.
9pub fn resample_sinc(
10    src: &[f32],
11    src_rate: u32,
12    dst_rate: u32,
13    out: &mut [f32],
14    half_taps: usize,
15) -> Result<usize, AudioError> {
16    if src_rate == 0 || dst_rate == 0 || half_taps == 0 {
17        return Err(AudioError::InvalidParameter);
18    }
19    if src.is_empty() {
20        return Err(AudioError::MalformedAudio);
21    }
22    Ok(etalon_signal::resample::windowed_sinc_resample_into(
23        src,
24        f64::from(src_rate),
25        f64::from(dst_rate),
26        half_taps,
27        0.0,
28        out,
29    ))
30}
31
32#[cfg(test)]
33mod tests {
34    use super::*;
35    use core::f64::consts::TAU;
36
37    /// Goertzel amplitude estimate at `freq` Hz over `sig` sampled at `fs`.
38    fn goertzel_amp(sig: &[f32], freq: f64, fs: f64) -> f64 {
39        let n = sig.len();
40        if n == 0 {
41            return 0.0;
42        }
43        let w = TAU * freq / fs;
44        let coeff = 2.0 * w.cos();
45        let mut s1 = 0.0f64;
46        let mut s2 = 0.0f64;
47        for &x in sig {
48            let s0 = x as f64 + coeff * s1 - s2;
49            s2 = s1;
50            s1 = s0;
51        }
52        let power = s1 * s1 + s2 * s2 - coeff * s1 * s2;
53        power.max(0.0).sqrt() * 2.0 / n as f64
54    }
55
56    fn rms(sig: &[f32]) -> f64 {
57        if sig.is_empty() {
58            return 0.0;
59        }
60        let s: f64 = sig.iter().map(|&x| x as f64 * x as f64).sum();
61        (s / sig.len() as f64).sqrt()
62    }
63
64    fn sine(freq: f64, amp: f64, n: usize, fs: f64) -> Vec<f32> {
65        (0..n)
66            .map(|i| (amp * (TAU * freq * i as f64 / fs).sin()) as f32)
67            .collect()
68    }
69
70    #[test]
71    fn identity_rate_returns_input() {
72        let s = [0.1f32, 0.2, 0.3, 0.4];
73        let mut o = [0.0f32; 4];
74        let n = resample_sinc(&s, 16000, 16000, &mut o, 16).unwrap();
75        assert_eq!(n, 4);
76        assert_eq!(o, s);
77    }
78
79    #[test]
80    fn dc_is_preserved() {
81        let s = vec![0.5f32; 256];
82        let mut o = vec![0.0f32; 128];
83        let n = resample_sinc(&s, 48000, 16000, &mut o, 16).unwrap();
84        assert!(n > 0);
85        for (k, &v) in o[..n].iter().enumerate() {
86            assert!((v - 0.5).abs() < 1e-3, "bin {k} = {v}, expected 0.5");
87        }
88    }
89
90    #[test]
91    fn ramp_value_is_preserved_interior() {
92        let s: Vec<f32> = (0..200).map(|j| 0.01 * j as f32).collect();
93        let mut o = vec![0.0f32; 100];
94        let half = 16usize;
95        let n = resample_sinc(&s, 48000, 24000, &mut o, half).unwrap();
96        for i in 25..=75 {
97            let center = 2.0 * i as f32;
98            let expected = 0.01 * center;
99            assert!(
100                (o[i] - expected).abs() < 1e-2,
101                "ramp[{i}] = {}, expected {expected}",
102                o[i]
103            );
104        }
105        let _ = n;
106    }
107
108    #[test]
109    fn anti_aliasing_downsample_rejects_out_of_band_tone() {
110        let src_rate = 48000u32;
111        let dst_rate = 8000u32;
112        let fs_out = dst_rate as f64;
113        let n_in = 4800usize; // 0.1 s
114        let amp = 0.8;
115        let half = 32usize;
116
117        let in_band = sine(1000.0, amp, n_in, src_rate as f64);
118        let mut out_in = vec![0.0f32; 900];
119        let n_in_out = resample_sinc(&in_band, src_rate, dst_rate, &mut out_in, half).unwrap();
120        let mid_in = &out_in[100..n_in_out.saturating_sub(100)];
121        let amp_1k = goertzel_amp(mid_in, 1000.0, fs_out);
122        assert!(
123            amp_1k > 0.6,
124            "in-band 1 kHz should survive ~unity (0.8), got {amp_1k}"
125        );
126
127        let out_band = sine(6000.0, amp, n_in, src_rate as f64);
128        let mut out_ob = vec![0.0f32; 900];
129        let n_ob_out = resample_sinc(&out_band, src_rate, dst_rate, &mut out_ob, half).unwrap();
130        let mid_ob = &out_ob[100..n_ob_out.saturating_sub(100)];
131
132        let alias_2k = goertzel_amp(mid_ob, 2000.0, fs_out);
133        assert!(
134            alias_2k < 0.1,
135            "aliased 2 kHz tone should be suppressed (< 0.1), got {alias_2k}"
136        );
137        let rms_ob = rms(mid_ob);
138        let rms_in = rms(mid_in);
139        assert!(
140            rms_ob < 0.15 * rms_in,
141            "out-of-band residual rms {rms_ob} should be ≪ in-band rms {rms_in}"
142        );
143    }
144
145    #[test]
146    fn rejects_bad_params() {
147        let s = [0.0f32; 4];
148        let mut o = [0.0f32; 4];
149        assert_eq!(
150            resample_sinc(&s, 0, 8000, &mut o, 8),
151            Err(AudioError::InvalidParameter)
152        );
153        assert_eq!(
154            resample_sinc(&s, 8000, 8000, &mut o, 0),
155            Err(AudioError::InvalidParameter)
156        );
157        assert_eq!(
158            resample_sinc(&[], 8000, 16000, &mut o, 8),
159            Err(AudioError::MalformedAudio)
160        );
161    }
162}