use super::*;
use crate::types::{MARGIN_SAMPLES, RATE_8K, WINDOW_SAMPLES};
use crate::vad::voice_activity_detection;
fn work(start: usize, end: usize) -> UtteranceWork {
UtteranceWork {
start,
end,
search_start: start,
search_end: end,
coarse: 0,
fine: 0,
confidence: 1.0,
}
}
fn two_bursts(burst_windows: usize, gap_windows: usize) -> SignalBuffer {
let burst = burst_windows * WINDOW_SAMPLES;
let gap = gap_windows * WINDOW_SAMPLES;
let len = 2 * burst + gap + 2 * MARGIN_SAMPLES;
let mut pcm = vec![0i16; len];
for i in 0..burst {
let phase = std::f32::consts::TAU * 1000.0 * i as f32 / 8000.0;
let sample = (3000.0 * phase.sin()) as i16;
pcm[i] = sample;
pcm[burst + gap + i] = sample;
}
SignalBuffer::from_pcm(&pcm).unwrap()
}
#[test]
fn boundary_merging_moves_edges_and_centers_midpoints() {
let mut utterances = vec![work(100, 200), work(300, 400), work(500, 600)];
merge_boundaries(&mut utterances, 800);
assert_eq!(utterances[0].start, 75);
assert_eq!(utterances[2].end, 800 - 75);
assert_eq!(utterances[0].end, 250);
assert_eq!(utterances[1].start, 250);
assert_eq!(utterances[1].end, 450);
assert_eq!(utterances[2].start, 450);
}
#[test]
fn two_bursts_yield_two_aligned_utterances() {
let reference = two_bursts(200, 200);
let degraded = reference.clone();
let ref_vad = voice_activity_detection(&reference);
let deg_vad = voice_activity_detection(°raded);
let utterances = align_utterances(&reference, °raded, &ref_vad, °_vad).unwrap();
assert_eq!(utterances.len(), 2);
assert_eq!(utterances[0].start_window, 75);
assert_eq!(utterances[0].end_window, 375);
assert_eq!(utterances[1].start_window, 375);
assert_eq!(utterances[1].end_window, ref_vad.window_count - 75);
for utterance in &utterances {
assert_eq!(utterance.fine_delay, 0);
assert!(utterance.confidence > 0.0);
}
}
fn bursty_noise(len: usize, amplitude: i16) -> SignalBuffer {
let mut pcm = vec![0i16; len];
let mut state = 7u32;
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) * f32::from(amplitude)) as i16;
}
burst += 90;
}
SignalBuffer::from_pcm(&pcm).unwrap()
}
#[test]
fn split_finds_the_delay_jump_in_a_long_utterance() {
let len = 16000usize;
let midpoint = len / 2;
let reference = bursty_noise(len, 3000);
let mut deg_pcm = vec![0i16; len];
for (i, sample) in deg_pcm.iter_mut().enumerate() {
let source = if i < midpoint {
i.saturating_sub(256)
} else {
i
};
*sample = reference.samples[MARGIN_SAMPLES + source] as i16;
}
let degraded = SignalBuffer::from_pcm(°_pcm).unwrap();
let ref_vad = voice_activity_detection(&reference);
let deg_vad = voice_activity_detection(°raded);
let utterances = align_utterances(&reference, °raded, &ref_vad, °_vad).unwrap();
assert!(utterances.len() >= 2, "expected a split: {utterances:?}");
let first = utterances[0];
let last = utterances[utterances.len() - 1];
assert!(
(first.fine_delay - 256).abs() <= 64,
"first delay {} should sit near 256",
first.fine_delay
);
assert!(
last.fine_delay.abs() <= 64,
"last delay {} should sit near 0",
last.fine_delay
);
let boundary = utterances[1].start_window;
assert!(boundary > 150 && boundary < 350, "boundary {boundary}");
assert!(first.confidence > 0.0 && last.confidence > 0.0);
}
#[test]
fn skip_flags_mark_the_frame_range_of_a_negative_jump() {
let utterances = vec![
Utterance {
start_window: 0,
end_window: 150,
coarse_delay: 0,
fine_delay: 0,
confidence: 0.0,
split_frame: None,
},
Utterance {
start_window: 200,
end_window: 400,
coarse_delay: -200,
fine_delay: -200,
confidence: 0.0,
split_frame: None,
},
];
let flags = negative_delay_skip_flags(&utterances, 40, RATE_8K);
assert!(!flags[17]);
assert!(flags[18]);
assert!(flags[33]);
assert!(!flags[34]);
}
#[test]
fn skip_flags_never_mark_frame_stop_itself() {
let utterances = vec![
Utterance {
start_window: 0,
end_window: 150,
coarse_delay: 0,
fine_delay: 0,
confidence: 0.0,
split_frame: None,
},
Utterance {
start_window: 200,
end_window: 400,
coarse_delay: -200,
fine_delay: -200,
confidence: 0.0,
split_frame: None,
},
];
let flags = negative_delay_skip_flags(&utterances, 33, RATE_8K);
assert!(flags[18]);
assert!(flags[32]);
assert!(!flags[33]);
}
#[test]
fn skip_flags_use_truncating_division_for_the_upper_bound() {
let utterances = vec![
Utterance {
start_window: 0,
end_window: 50,
coarse_delay: 0,
fine_delay: 0,
confidence: 0.0,
split_frame: None,
},
Utterance {
start_window: 60,
end_window: 400,
coarse_delay: -256,
fine_delay: -256,
confidence: 0.0,
split_frame: None,
},
];
let flags = negative_delay_skip_flags(&utterances, 40, RATE_8K);
assert!(flags[0]);
assert!(!flags[1]);
}
#[test]
fn skip_flags_ignore_small_jumps() {
let utterances = vec![
Utterance {
start_window: 0,
end_window: 150,
coarse_delay: 0,
fine_delay: 0,
confidence: 0.0,
split_frame: None,
},
Utterance {
start_window: 200,
end_window: 400,
coarse_delay: -100,
fine_delay: -100,
confidence: 0.0,
split_frame: None,
},
];
let flags = negative_delay_skip_flags(&utterances, 40, RATE_8K);
assert!(flags.iter().all(|&flag| !flag));
}
#[test]
fn align_utterances_finds_one_utterance_for_silence() {
let reference = SignalBuffer::from_pcm(&vec![0i16; 4000]).unwrap();
let degraded = reference.clone();
let ref_vad = voice_activity_detection(&reference);
let deg_vad = voice_activity_detection(°raded);
let utterances = align_utterances(&reference, °raded, &ref_vad, °_vad).unwrap();
assert_eq!(utterances.len(), 1);
assert_eq!(utterances[0].start_window, 75);
assert_eq!(utterances[0].end_window, ref_vad.window_count - 75);
assert_eq!(utterances[0].fine_delay, 0);
}
#[test]
fn align_utterances_rejects_runs_outside_the_degredation_bounds() {
let total = 400usize;
let mut ref_log = vec![0.0f32; total];
let mut deg_log = vec![0.0f32; total];
for value in ref_log[100..140].iter_mut() {
*value = 1.0;
}
for value in deg_log[360..400].iter_mut() {
*value = 1.0;
}
let mut ref_energy = ref_log.clone();
for value in ref_energy[100..140].iter_mut() {
*value = 1.0;
}
let ref_vad = VadData {
window_count: total,
energy: ref_energy,
log_vad: ref_log,
threshold: 0.5,
signal_level: 1.0,
noise_level: 0.0,
};
let deg_vad = VadData {
window_count: total,
energy: vec![0.0; total],
log_vad: deg_log,
threshold: 0.5,
signal_level: 1.0,
noise_level: 0.0,
};
let reference = SignalBuffer::from_pcm(&vec![0i16; 4000]).unwrap();
let result = align_utterances(&reference, &reference, &ref_vad, °_vad);
assert_eq!(result.unwrap_err(), PesqError::NoUtterancesFound);
}