use crate::input_buffers::normalize_levels;
use crate::input_filters::{apply_irs_receive, apply_wideband, input_iir_filter, remove_dc};
use crate::types::{PesqError, SignalBuffer, Utterance};
use crate::utterances::align_utterances;
use crate::vad::voice_activity_detection;
const DECIMATOR_CUTOFF_HZ: f64 = 0.45 * 8000.0 / 2.0;
const DECIMATOR_HALF_TAPS: usize = 16;
pub fn decimate_16k_to_8k(pcm: &[i16]) -> Vec<i16> {
let taps = decimator_taps();
let half = DECIMATOR_HALF_TAPS as isize;
let mut output = Vec::with_capacity(pcm.len() / 2);
for j in 0..output.capacity() {
let mut sum = 0.0f64;
for (tap_index, &coefficient) in taps.iter().enumerate() {
let offset = 2 * j as isize - (tap_index as isize - half);
if offset >= 0 && offset < pcm.len() as isize {
sum += coefficient * f64::from(pcm[offset as usize]);
}
}
output.push(sum.round().clamp(-32768.0, 32767.0) as i16);
}
output
}
fn decimator_taps() -> &'static [f64] {
use std::sync::OnceLock;
static TAPS: OnceLock<Vec<f64>> = OnceLock::new();
TAPS.get_or_init(|| {
let cutoff = DECIMATOR_CUTOFF_HZ / 16000.0;
let length = 2 * DECIMATOR_HALF_TAPS + 1;
let mut taps = vec![0.0f64; length];
for (i, tap) in taps.iter_mut().enumerate() {
let n = i as isize - DECIMATOR_HALF_TAPS as isize;
let sinc = if n == 0 {
2.0 * cutoff
} else {
(2.0 * core::f64::consts::PI * cutoff * n as f64).sin()
/ (core::f64::consts::PI * n as f64)
};
let window =
0.54 - 0.46 * (2.0 * core::f64::consts::PI * i as f64 / (length - 1) as f64).cos();
*tap = sinc * window;
}
let sum: f64 = taps.iter().sum();
for tap in taps.iter_mut() {
*tap /= sum;
}
taps
})
}
pub fn prepare_input(pcm_16k: &[i16]) -> Result<SignalBuffer, PesqError> {
SignalBuffer::from_pcm(&decimate_16k_to_8k(pcm_16k))
}
#[derive(Debug, Clone)]
pub struct AlignedPair {
pub reference: SignalBuffer,
pub degraded: SignalBuffer,
pub utterances: Vec<Utterance>,
}
impl AlignedPair {
pub fn nominal_max(&self) -> usize {
self.reference.nominal_len.max(self.degraded.nominal_len)
}
}
pub fn process_pair(
reference: SignalBuffer,
degraded: SignalBuffer,
) -> Result<AlignedPair, PesqError> {
process_pair_mode(reference, degraded, false)
}
pub fn process_pair_wideband(
reference: SignalBuffer,
degraded: SignalBuffer,
) -> Result<AlignedPair, PesqError> {
process_pair_mode(reference, degraded, true)
}
fn process_pair_mode(
mut reference: SignalBuffer,
mut degraded: SignalBuffer,
wideband: bool,
) -> Result<AlignedPair, PesqError> {
normalize_levels(&mut reference, &mut degraded);
let (mut model_reference, mut model_degraded) = if wideband {
apply_wideband(&mut reference, &mut degraded)
} else {
apply_irs_receive(&mut reference, &mut degraded)
};
for buffer in [&mut reference, &mut degraded] {
remove_dc(buffer);
input_iir_filter(buffer);
}
let ref_vad = voice_activity_detection(&reference);
let deg_vad = voice_activity_detection(°raded);
let utterances = align_utterances(&reference, °raded, &ref_vad, °_vad)?;
let n_max = reference.nominal_len.max(degraded.nominal_len);
for model in [&mut model_reference, &mut model_degraded] {
model
.samples
.resize(n_max + reference.rate.padding_samples(), 0.0);
}
Ok(AlignedPair {
reference: model_reference,
degraded: model_degraded,
utterances,
})
}
pub fn coarse_delay(reference: &crate::types::VadData, degraded: &crate::types::VadData) -> i32 {
crate::alignment::coarse_delay_whole(reference, degraded, crate::types::RATE_8K)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{PADDING_SAMPLES, WINDOW_SAMPLES};
#[test]
fn decimation_halves_the_rate_and_drops_a_trailing_odd_sample() {
let input = [100i16, 200, 300, 400, 500, 600];
assert_eq!(decimate_16k_to_8k(&input).len(), 3);
let odd = [100i16, 200, 300];
assert_eq!(decimate_16k_to_8k(&odd).len(), 1);
}
#[test]
fn decimation_has_unit_dc_gain() {
let input = vec![1000i16; 128];
let output = decimate_16k_to_8k(&input);
for &sample in &output[24..40] {
assert_eq!(sample, 1000);
}
}
#[test]
fn decimation_impulse_response_energy() {
let mut input = vec![0i16; 256];
input[0] = 30000;
let output = decimate_16k_to_8k(&input);
let energy: f64 = output.iter().map(|&s| f64::from(s) * f64::from(s)).sum();
let normalized = energy / (30000.0 * 30000.0);
assert!(
(normalized - 0.075_838_833_052_037_23).abs() < 1e-4,
"normalized impulse response energy {normalized} diverged from the pinned design"
);
}
#[test]
fn decimation_frequency_response() {
for &(frequency, lower, upper) in &[
(400.0f64, 0.99f64, 1.01f64),
(1000.0f64, 0.98f64, 1.02f64),
(1800.0f64, 0.48f64, 0.52f64),
(3000.0f64, 0.0f64, 0.01f64),
(4000.0f64, 0.0f64, 0.01f64),
(5000.0f64, 0.0f64, 0.01f64),
] {
let input: Vec<i16> = (0..1600)
.map(|i| {
let phase = 2.0 * core::f64::consts::PI * frequency * i as f64 / 16000.0;
(phase.sin() * 10000.0).round() as i16
})
.collect();
let output = decimate_16k_to_8k(&input);
let rms = |samples: &[i16]| -> f64 {
(samples
.iter()
.map(|&s| f64::from(s) * f64::from(s))
.sum::<f64>()
/ samples.len() as f64)
.sqrt()
};
let gain = rms(&output[200..600]) / rms(&input);
assert!(
gain >= lower && gain <= upper,
"gain {gain:.5} at {frequency} Hz outside [{lower}, {upper}]"
);
}
}
#[test]
fn prepare_input_enforces_the_minimum_length() {
let too_short = vec![0i16; 2 * crate::types::MIN_INPUT_SAMPLES - 1];
assert_eq!(
prepare_input(&too_short).unwrap_err(),
PesqError::SignalTooShort {
samples: crate::types::MIN_INPUT_SAMPLES - 1
}
);
let ok = vec![0i16; 2 * crate::types::MIN_INPUT_SAMPLES];
assert!(prepare_input(&ok).is_ok());
}
fn noise_pair(reference_len: usize, degraded_len: usize) -> (SignalBuffer, SignalBuffer) {
let build = |len: usize| {
let mut pcm = vec![0i16; len];
let mut state = 21u32;
let mut burst = 75usize;
let last = len / WINDOW_SAMPLES - 75;
while burst + 60 <= last {
for i in 0..60 * WINDOW_SAMPLES {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
pcm[burst * WINDOW_SAMPLES + i] =
(((state as f32 / u32::MAX as f32) * 2.0 - 1.0) * 3000.0) as i16;
}
burst += 90;
}
SignalBuffer::from_pcm(&pcm).unwrap()
};
(build(reference_len), build(degraded_len))
}
#[test]
fn process_pair_aligns_and_equalizes_the_model_copies() {
let (reference, degraded) = noise_pair(8000, 12000);
let pair = process_pair(reference, degraded).unwrap();
let n_max = pair.nominal_max();
assert_eq!(
pair.reference.samples.len(),
n_max + crate::types::PADDING_SAMPLES
);
assert_eq!(pair.degraded.samples.len(), n_max + PADDING_SAMPLES);
assert!(!pair.utterances.is_empty());
for utterance in &pair.utterances {
assert_eq!(utterance.fine_delay, 0);
}
}
#[test]
fn process_pair_accepts_identical_buffers() {
let (reference, degraded) = noise_pair(8000, 8000);
let pair = process_pair(reference, degraded).unwrap();
assert!(!pair.utterances.is_empty());
assert!(pair.utterances[0].start_window >= 75);
}
}