use crate::dsp::{IRS_RECEIVE_CURVE, apply_filter_curve, apply_input_iir};
use crate::types::{RATE_16K, SignalBuffer};
pub fn apply_irs_receive(
reference: &mut SignalBuffer,
degraded: &mut SignalBuffer,
) -> (SignalBuffer, SignalBuffer) {
apply_filter_curve(&mut reference.samples, &IRS_RECEIVE_CURVE, reference.rate);
apply_filter_curve(&mut degraded.samples, &IRS_RECEIVE_CURVE, degraded.rate);
(reference.clone(), degraded.clone())
}
pub fn apply_wideband(
reference: &mut SignalBuffer,
degraded: &mut SignalBuffer,
) -> (SignalBuffer, SignalBuffer) {
wideband_filter(reference);
wideband_filter(degraded);
(reference.clone(), degraded.clone())
}
#[allow(clippy::excessive_precision)]
const WIDEBAND_SECTION: [f32; 5] = [
2.740_826,
-5.481_651_9,
2.740_826,
-1.944_477_7,
0.945_977_94,
];
const WIDEBAND_RAMP_SAMPLES: usize = 16;
fn wideband_filter(buffer: &mut SignalBuffer) {
assert_eq!(
buffer.rate, RATE_16K,
"wideband mode requires the 16 kHz rate (spec 06, 6.2 item 2)"
);
let start = buffer.rate.margin_samples();
let end = buffer.nominal_len - start;
for k in 0..WIDEBAND_RAMP_SAMPLES {
buffer.samples[start + k] *= (k + 1) as f32 / WIDEBAND_RAMP_SAMPLES as f32;
buffer.samples[end - 1 - k] *= (k + 1) as f32 / WIDEBAND_RAMP_SAMPLES as f32;
}
let [b0, b1, b2, a1, a2] = WIDEBAND_SECTION;
let mut w1 = 0.0f32;
let mut w2 = 0.0f32;
for sample in buffer.samples[start..end].iter_mut() {
let w = *sample - a1 * w1 - a2 * w2;
*sample = b0 * w + b1 * w1 + b2 * w2;
w2 = w1;
w1 = w;
}
}
pub fn remove_dc(buffer: &mut SignalBuffer) {
let start = buffer.rate.margin_samples();
let end = buffer.nominal_len - start;
let sum: f64 = buffer.samples[start..end]
.iter()
.map(|&sample| f64::from(sample))
.sum();
let mean = (sum / buffer.nominal_len as f64) as f32;
for sample in buffer.samples[start..end].iter_mut() {
*sample -= mean;
}
let w = buffer.rate.window_samples();
for k in 0..w {
buffer.samples[start + k] *= (0.5 + k as f32) / w as f32;
}
for k in 0..w {
buffer.samples[end - 1 - k] *= (0.5 + k as f32) / w as f32;
}
}
pub fn input_iir_filter(buffer: &mut SignalBuffer) {
apply_input_iir(&mut buffer.samples, buffer.rate);
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{MARGIN_SAMPLES, WINDOW_SAMPLES};
fn constant_buffer(value: f32, len: usize) -> SignalBuffer {
let mut buffer = SignalBuffer::from_pcm(&vec![0i16; len]).unwrap();
for sample in buffer.samples[MARGIN_SAMPLES..MARGIN_SAMPLES + len].iter_mut() {
*sample = value;
}
buffer
}
#[test]
fn dc_removal_divides_by_the_nominal_length() {
let value = 100.0f32;
let len = 4000usize;
let mut buffer = constant_buffer(value, len);
let residual = value * (2.0 * MARGIN_SAMPLES as f32) / buffer.nominal_len as f32;
remove_dc(&mut buffer);
let interior = MARGIN_SAMPLES + WINDOW_SAMPLES;
let interior_end = buffer.nominal_len - MARGIN_SAMPLES - WINDOW_SAMPLES;
for &sample in &buffer.samples[interior..interior_end] {
assert!(
(sample - residual).abs() < 1e-3,
"sample {sample}, residual {residual}"
);
}
}
#[test]
fn dc_removal_ramps_the_interval_edges() {
let value = 100.0f32;
let len = 4000usize;
let mut buffer = constant_buffer(value, len);
let residual = value * (2.0 * MARGIN_SAMPLES as f32) / buffer.nominal_len as f32;
remove_dc(&mut buffer);
let start = MARGIN_SAMPLES;
let end = buffer.nominal_len - MARGIN_SAMPLES;
for k in 0..WINDOW_SAMPLES {
let factor = (0.5 + k as f32) / WINDOW_SAMPLES as f32;
assert!(
(buffer.samples[start + k] - residual * factor).abs() < 1e-3,
"start ramp k={k}"
);
assert!(
(buffer.samples[end - 1 - k] - residual * factor).abs() < 1e-3,
"end ramp k={k}"
);
}
}
#[test]
fn dc_removal_leaves_the_margins_untouched() {
let len = 4000usize;
let mut buffer = constant_buffer(100.0, len);
remove_dc(&mut buffer);
assert!(buffer.samples[..MARGIN_SAMPLES].iter().all(|&s| s == 0.0));
assert!(
buffer.samples[buffer.nominal_len - MARGIN_SAMPLES..]
.iter()
.all(|&s| s == 0.0)
);
}
#[test]
fn iir_filter_preserves_silence() {
let len = 4000usize;
let mut buffer = SignalBuffer::from_pcm(&vec![0i16; len]).unwrap();
input_iir_filter(&mut buffer);
assert!(buffer.samples.iter().all(|&s| s == 0.0));
}
#[test]
fn wideband_filter_ramps_the_edges_and_shapes_the_region() {
let len = 8000usize;
let mut buffer =
SignalBuffer::from_pcm_at(&vec![0i16; len], crate::types::RATE_16K).unwrap();
let margin = buffer.rate.margin_samples();
for sample in buffer.samples[margin..margin + len].iter_mut() {
*sample = 1.0;
}
wideband_filter(&mut buffer);
assert!(buffer.samples[..margin].iter().all(|&s| s == 0.0));
assert!(
buffer.samples[buffer.nominal_len - margin..]
.iter()
.all(|&s| s == 0.0)
);
assert!((buffer.samples[margin] - 2.740_826 / 16.0).abs() < 1e-4);
let mid = margin + 2000;
assert!(
(buffer.samples[mid].abs()) < 1e-3,
"mid {}",
buffer.samples[mid]
);
let mut eight_k = SignalBuffer::from_pcm(&vec![0i16; len]).unwrap();
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
wideband_filter(&mut eight_k);
}));
assert!(result.is_err(), "wideband at 8 kHz must be rejected");
}
#[test]
fn irs_receive_saves_the_model_copies() {
let len = 4000usize;
let mut reference = constant_buffer(100.0, len);
let mut degraded = constant_buffer(50.0, len);
let (model_ref, model_deg) = apply_irs_receive(&mut reference, &mut degraded);
assert_eq!(model_ref.samples, reference.samples);
assert_eq!(model_deg.samples, degraded.samples);
assert!(reference.samples[MARGIN_SAMPLES] != 100.0);
}
}