use crate::alignment::{coarse_delay_search, fine_delay, qualifying_runs, search_windows};
use crate::splitting::best_split;
use crate::types::{PesqError, Rate, SignalBuffer, Utterance, VadData};
const MAX_UTTERANCES: usize = 50;
#[derive(Debug, Clone)]
pub(crate) struct UtteranceWork {
pub(crate) start: usize,
pub(crate) end: usize,
pub(crate) search_start: usize,
pub(crate) search_end: usize,
pub(crate) coarse: i32,
pub(crate) fine: i32,
pub(crate) confidence: f32,
}
pub fn align_utterances(
reference: &SignalBuffer,
degraded: &SignalBuffer,
ref_vad: &VadData,
deg_vad: &VadData,
) -> Result<Vec<Utterance>, PesqError> {
let rate = reference.rate;
let coarse = crate::alignment::coarse_delay_whole(ref_vad, deg_vad, rate);
let runs = qualifying_runs(ref_vad, coarse, degraded.nominal_len, rate);
if runs.is_empty() {
return Err(PesqError::NoUtterancesFound);
}
let windows = search_windows(ref_vad, coarse, degraded.nominal_len, rate);
let mut utterances: Vec<UtteranceWork> = runs
.iter()
.zip(windows.iter())
.map(|(&(start, end), &(search_start, search_end))| {
let per_utterance =
coarse_delay_search(ref_vad, deg_vad, search_start, search_end, coarse, rate);
let (fine, confidence) = fine_delay(
&reference.samples,
°raded.samples,
search_start,
search_end,
per_utterance,
degraded.nominal_len,
rate,
);
UtteranceWork {
start,
end,
search_start,
search_end,
coarse: per_utterance,
fine,
confidence,
}
})
.collect();
merge_boundaries(&mut utterances, ref_vad.window_count);
clamp_boundaries(&mut utterances, degraded.nominal_len, rate);
split_utterances(&mut utterances, reference, degraded, ref_vad, deg_vad);
Ok(utterances
.iter()
.map(|work| Utterance {
start_window: work.start,
end_window: work.end,
coarse_delay: work.coarse,
fine_delay: work.fine,
confidence: work.confidence,
split_frame: None,
})
.collect())
}
fn merge_boundaries(utterances: &mut [UtteranceWork], window_count: usize) {
if utterances.is_empty() {
return;
}
let last = utterances.len() - 1;
utterances[0].start = 75;
utterances[last].end = window_count - 75;
for u in 1..utterances.len() {
let midpoint = (utterances[u].start + utterances[u - 1].end) / 2;
utterances[u - 1].end = midpoint;
utterances[u].start = midpoint;
}
}
fn clamp_boundaries(utterances: &mut [UtteranceWork], degraded_nominal: usize, rate: Rate) {
let window = rate.window_samples() as i64;
let margin = rate.margin_samples() as i64;
let Some(first) = utterances.first_mut() else {
return;
};
if first.start as i64 * window + i64::from(first.fine) < margin {
first.start = (75 + (window as i32 - 1 - first.fine) / window as i32) as usize;
}
if let Some(last) = utterances.last_mut() {
if last.end as i64 * window + i64::from(last.fine) > degraded_nominal as i64 - margin {
let end = (degraded_nominal as i64 - i64::from(last.fine)) / window - margin / window;
last.end = end.max(0) as usize;
}
}
for u in 1..utterances.len() {
let a = utterances[u].start as i64 * window + i64::from(utterances[u].fine);
let b = utterances[u - 1].end as i64 * window + i64::from(utterances[u - 1].fine);
if a < b {
let c = (a + b) / 2;
utterances[u].start =
((window - 1 + c - i64::from(utterances[u].fine)) / window).max(0) as usize;
utterances[u - 1].end =
((c - i64::from(utterances[u - 1].fine)) / window).max(0) as usize;
}
}
}
fn split_utterances(
utterances: &mut Vec<UtteranceWork>,
reference: &SignalBuffer,
degraded: &SignalBuffer,
ref_vad: &VadData,
deg_vad: &VadData,
) {
let mut u = 0;
while u < utterances.len() && utterances.len() < MAX_UTTERANCES {
let work = &utterances[u];
let Some(split) = best_split(work, reference, degraded, ref_vad, deg_vad) else {
u += 1;
continue;
};
let (left_end, right_start) = if split.backward_delay < split.forward_delay {
(split.breakpoint, split.breakpoint)
} else {
let half = (split.backward_delay - split.forward_delay)
/ (2 * reference.rate.window_samples() as i32);
(
split.breakpoint + half as usize,
split.breakpoint.saturating_sub(half as usize),
)
};
let mut left = UtteranceWork {
start: work.start,
end: left_end,
search_start: work.search_start,
search_end: work.search_end,
coarse: split.left_estimate,
fine: split.forward_delay,
confidence: split.forward_confidence,
};
let mut right = UtteranceWork {
start: right_start,
end: work.end,
search_start: work.search_start,
search_end: work.search_end,
coarse: split.right_estimate,
fine: split.backward_delay,
confidence: split.backward_confidence,
};
let window = reference.rate.window_samples() as i64;
let margin = reference.rate.margin_samples() as i64;
if (left.start as i64 - 75) * window + i64::from(left.fine) < 0 {
left.start = (75 + (window as i32 - 1 - left.fine) / window as i32) as usize;
}
if right.end as i64 * window + i64::from(right.fine) > degraded.nominal_len as i64 - margin
{
let end = (degraded.nominal_len as i64 - i64::from(right.fine)) / window - 75;
right.end = end.max(0) as usize;
}
utterances[u] = left;
utterances.insert(u + 1, right);
for work in utterances.iter_mut().skip(u + 2) {
work.search_start = work.start;
work.search_end = work.end;
}
}
}
pub fn negative_delay_skip_flags(
utterances: &[Utterance],
frame_stop: usize,
rate: Rate,
) -> Vec<bool> {
let window = rate.window_samples() as i64;
let hop = rate.frame_hop() as i64;
let mut flags = vec![false; frame_stop + 1];
for pair in utterances.windows(2) {
let j0 = i64::from(pair[0].fine_delay);
let j1 = i64::from(pair[1].fine_delay);
if j1 - j0 < -128 {
let mut f1 = ((pair[1].start_window as i64 - 75) * window + j1) / hop;
let j = ((pair[0].end_window as i64 - 75) * window + j0) / hop;
if f1 > j {
f1 = j;
}
if f1 < 0 {
f1 = 0;
}
let f2 =
((pair[1].start_window as i64 - 75) * window + (j1 - j0).abs().max(0)) / hop + 1;
let last = f2.min(frame_stop as i64 - 1);
for frame in f1..=last {
flags[frame as usize] = true;
}
}
}
flags
}
#[cfg(test)]
mod tests;