use crate::dsp::{circular_convolve, correlate, hann_window, spectral_cross_correlate};
use crate::types::{RATE_8K, RATE_16K, Rate, VadData};
fn smooth_kernel(rate: Rate) -> &'static [f32] {
use std::sync::OnceLock;
static KERNEL_8K: OnceLock<Vec<f32>> = OnceLock::new();
static KERNEL_16K: OnceLock<Vec<f32>> = OnceLock::new();
let slot = match rate {
RATE_8K => &KERNEL_8K,
RATE_16K => &KERNEL_16K,
};
slot.get_or_init(|| {
let align_fft_len = rate.align_fft_len();
let radius = align_fft_len / 64;
let mut kernel = vec![0.0f32; align_fft_len];
kernel[0] = 1.0;
for k in 1..radius {
let value = 1.0 - k as f32 / radius as f32;
kernel[k] = value;
kernel[align_fft_len - k] = value;
}
kernel
})
}
fn fine_advance(rate: Rate) -> usize {
rate.align_fft_len() / 4
}
pub fn coarse_delay_whole(reference: &VadData, degraded: &VadData, rate: Rate) -> i32 {
let x = &reference.log_vad;
let y = °raded.log_vad;
if x.len() <= 1 || y.len() <= 1 {
return 0;
}
lag_from_correlation(&correlate(x, y), x.len(), rate.window_samples())
}
pub fn coarse_delay_search(
reference: &VadData,
degraded: &VadData,
s0: usize,
s1: usize,
seed: i32,
rate: Rate,
) -> i32 {
match coarse_correlation(reference, degraded, s0, s1, seed, rate) {
Some((estimate, _)) => estimate,
None => seed,
}
}
pub fn fine_delay(
reference: &[f32],
degraded: &[f32],
s0: usize,
s1: usize,
d0: i32,
degraded_nominal: usize,
rate: Rate,
) -> (i32, f32) {
let align_fft_len = rate.align_fft_len();
let window = hann_window(align_fft_len);
let mut histogram = vec![0.0f32; align_fft_len];
let mut ref_cursor = (s0 * rate.window_samples()) as i64;
let mut deg_cursor = ref_cursor + i64::from(d0);
if deg_cursor < 0 {
ref_cursor = i64::from(-d0);
deg_cursor = 0;
}
let mut frame_ref = vec![0.0f32; align_fft_len];
let mut frame_deg = vec![0.0f32; align_fft_len];
while deg_cursor + align_fft_len as i64 <= degraded_nominal as i64
&& ref_cursor + align_fft_len as i64 <= (s1 * rate.window_samples()) as i64
{
let ref_start = ref_cursor as usize;
let deg_start = deg_cursor as usize;
for i in 0..align_fft_len {
frame_ref[i] = window[i] * reference[ref_start + i];
frame_deg[i] = window[i] * degraded[deg_start + i];
}
let spectrum = spectral_cross_correlate(&frame_ref, &frame_deg);
let peak = spectrum
.iter()
.map(|value| value.abs())
.fold(0.0f32, f32::max);
let threshold = 0.99 * peak;
let weight = threshold.powf(0.125);
for (lag, &value) in spectrum.iter().enumerate() {
if value.abs() > threshold {
histogram[lag] += weight;
}
}
ref_cursor += fine_advance(rate) as i64;
deg_cursor += fine_advance(rate) as i64;
}
let raw_sum: f64 = histogram.iter().map(|&h| f64::from(h)).sum();
histogram = circular_convolve(&histogram, smooth_kernel(rate));
if raw_sum > 0.0 {
let raw_sum = raw_sum as f32;
for h in histogram.iter_mut() {
*h = (*h / raw_sum).abs();
}
} else {
histogram.fill(0.0);
}
let mut peak_index = 0usize;
let mut peak_value = 0.0f32;
for (lag, &value) in histogram.iter().enumerate() {
if value > peak_value {
peak_value = value;
peak_index = lag;
}
}
let folded = if peak_index >= align_fft_len / 2 {
peak_index as i32 - align_fft_len as i32
} else {
peak_index as i32
};
(d0 + folded, peak_value)
}
fn lag_from_correlation(correlation: &[f32], vr: usize, window_samples: usize) -> i32 {
let (best_index, _) = maximizer(correlation, vr - 1);
(best_index as i32 - vr as i32 + 1) * window_samples as i32
}
fn maximizer(values: &[f32], vr: usize) -> (usize, f32) {
let mut best_value = 0.0f32;
let mut best_index = vr;
for (index, &value) in values.iter().enumerate() {
if value > best_value {
best_value = value;
best_index = index;
}
}
(best_index, best_value)
}
pub fn search_windows(
reference: &VadData,
coarse_delay: i32,
degraded_nominal: usize,
rate: Rate,
) -> Vec<(usize, usize)> {
let last = reference.window_count - 1;
qualifying_runs(reference, coarse_delay, degraded_nominal, rate)
.into_iter()
.map(|(a, c)| (a.saturating_sub(75), (c + 75).min(last)))
.collect()
}
pub fn qualifying_runs(
reference: &VadData,
coarse_delay: i32,
degraded_nominal: usize,
rate: Rate,
) -> Vec<(usize, usize)> {
let window_divisor = rate.window_samples() as i32;
let b1 = 50 - coarse_delay / window_divisor;
let b2 = (degraded_nominal as i32 - coarse_delay) / window_divisor - 50;
let last = reference.window_count - 1;
let mut runs = Vec::new();
let mut a = 0usize;
while a < reference.window_count {
if reference.energy[a] == 0.0 {
a += 1;
continue;
}
let start = a;
while a < reference.window_count && reference.energy[a] > 0.0 {
a += 1;
}
let (c, length) = if a == reference.window_count {
(last, last - start)
} else {
(a, a - start)
};
if length >= 50 && (start as i64) < i64::from(b2) && (c as i64) > i64::from(b1) {
runs.push((start, c));
}
}
runs
}
pub(crate) fn coarse_correlation(
reference: &VadData,
degraded: &VadData,
s0: usize,
s1: usize,
seed: i32,
rate: Rate,
) -> Option<(i32, Vec<f32>)> {
let window_divisor = rate.window_samples() as i32;
let mut s0 = s0;
let mut sd = s0 as i32 + seed / window_divisor;
if sd < 0 {
s0 = ((-seed) / window_divisor) as usize;
sd = 0;
}
if s0 >= s1 {
return None;
}
let nr = s1 - s0;
let mut nd = nr;
if sd as usize + nd > degraded.window_count {
nd = degraded.window_count - sd as usize;
}
if nr <= 1 || nd <= 1 {
return None;
}
let x = &reference.log_vad[s0..s0 + nr];
let y = °raded.log_vad[sd as usize..sd as usize + nd];
let correlation = correlate(x, y);
let (best_index, _) = maximizer(&correlation, nr - 1);
Some((
(best_index as i32 - nr as i32 + 1) * window_divisor + seed,
correlation,
))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{RATE_8K, SignalBuffer, WINDOW_SAMPLES};
fn vad_with_burst(total: usize, onset: usize, run: usize) -> VadData {
let mut energy = vec![0.0f32; total];
for e in energy[onset..onset + run].iter_mut() {
*e = 1.0;
}
let log_vad = energy
.iter()
.map(|&e| if e > 0.0 { 1.0 } else { 0.0 })
.collect();
VadData {
window_count: total,
energy,
log_vad,
threshold: 0.5,
signal_level: 1.0,
noise_level: 0.0,
}
}
#[test]
fn coarse_delay_finds_a_shifted_log_vad_burst() {
let total = 400usize;
let shift = 6usize;
let reference = vad_with_burst(total, 100, 40);
let degraded = vad_with_burst(total, 100 + shift, 40);
let lag = coarse_delay_whole(&reference, °raded, RATE_8K);
assert_eq!(lag, shift as i32 * WINDOW_SAMPLES as i32);
}
#[test]
fn coarse_delay_is_zero_for_single_window_vad() {
let tiny = vad_with_burst(1, 0, 1);
assert_eq!(coarse_delay_whole(&tiny, &tiny, RATE_8K), 0);
}
#[test]
fn per_utterance_coarse_seeds_from_the_window() {
let total = 400usize;
let reference = vad_with_burst(total, 100, 40);
let degraded = vad_with_burst(total, 106, 40);
let estimate = coarse_delay_search(&reference, °raded, 25, 235, 0, RATE_8K);
assert_eq!(estimate, 6 * WINDOW_SAMPLES as i32);
}
#[test]
fn per_utterance_coarse_returns_the_seed_for_tiny_windows() {
let reference = vad_with_burst(400, 100, 40);
let degraded = vad_with_burst(400, 100, 40);
assert_eq!(
coarse_delay_search(&reference, °raded, 100, 101, 17, RATE_8K),
17
);
}
fn shifted_pair(shift: usize) -> (SignalBuffer, SignalBuffer) {
let signal_len = 16000usize;
let mut state = 99u32;
let mut ref_pcm = vec![0i16; signal_len];
for sample in ref_pcm[2000..12000].iter_mut() {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
*sample = ((state as f32 / u32::MAX as f32) * 8000.0 - 4000.0) as i16;
}
let reference = SignalBuffer::from_pcm(&ref_pcm).unwrap();
let mut deg_pcm = vec![0i16; shift];
deg_pcm.extend_from_slice(&ref_pcm);
let degraded = SignalBuffer::from_pcm(°_pcm[..signal_len]).unwrap();
(reference, degraded)
}
#[test]
fn fine_delay_recovers_a_known_sample_shift() {
let (reference, degraded) = shifted_pair(64);
let (delay, confidence) = fine_delay(
&reference.samples,
°raded.samples,
75,
reference.nominal_len / WINDOW_SAMPLES - 75,
0,
degraded.nominal_len,
RATE_8K,
);
assert_eq!(delay, 64);
assert!(confidence > 0.0);
}
#[test]
fn fine_delay_is_zero_for_identical_buffers() {
let (reference, _) = shifted_pair(0);
let (delay, confidence) = fine_delay(
&reference.samples,
&reference.samples,
75,
reference.nominal_len / WINDOW_SAMPLES - 75,
0,
reference.nominal_len,
RATE_8K,
);
assert_eq!(delay, 0);
assert!(confidence > 0.0);
}
#[test]
fn fine_delay_respects_the_degraded_length_clamp() {
let (reference, _) = shifted_pair(0);
let (delay, confidence) = fine_delay(
&reference.samples,
&reference.samples,
75,
reference.nominal_len / WINDOW_SAMPLES - 75,
0,
WINDOW_SAMPLES,
RATE_8K,
);
assert_eq!(delay, 0);
assert_eq!(confidence, 0.0);
}
#[test]
fn search_windows_follow_the_run_qualification_rules() {
let mut vad = vad_with_burst(400, 100, 60);
for e in vad.energy[300..360].iter_mut() {
*e = 1.0;
}
let windows = search_windows(&vad, 0, 400 * WINDOW_SAMPLES, RATE_8K);
assert_eq!(windows, vec![(25, 235), (225, 399)]);
}
#[test]
fn search_windows_reject_short_runs() {
let vad = vad_with_burst(400, 100, 49);
assert!(search_windows(&vad, 0, 400 * WINDOW_SAMPLES, RATE_8K).is_empty());
}
#[test]
fn coarse_maximizer_falls_back_to_zero_lag() {
let negative = [-1.0f32, -2.0, -3.0];
assert_eq!(lag_from_correlation(&negative, 4, WINDOW_SAMPLES), 0);
let zeros = [0.0f32; 9];
assert_eq!(lag_from_correlation(&zeros, 4, WINDOW_SAMPLES), 0);
}
}