use crate::alignment::coarse_correlation;
use crate::dsp::{hann_window, spectral_cross_correlate};
use crate::types::{Rate, SignalBuffer, VadData};
use crate::utterances::UtteranceWork;
const MIN_SPLIT_SPEECH_WINDOWS: usize = 200;
const SPLIT_MAX_CANDIDATES: usize = 40;
fn split_grid_step(rate: Rate) -> usize {
rate.align_fft_len() / (4 * rate.window_samples())
}
fn scratch_window_offset(rate: Rate) -> usize {
3 * rate.align_fft_len() + 6
}
pub(crate) struct Split {
pub(crate) breakpoint: usize,
pub(crate) left_estimate: i32,
pub(crate) right_estimate: i32,
pub(crate) forward_delay: i32,
pub(crate) backward_delay: i32,
pub(crate) forward_confidence: f32,
pub(crate) backward_confidence: f32,
}
pub(crate) fn best_split(
work: &UtteranceWork,
reference: &SignalBuffer,
degraded: &SignalBuffer,
ref_vad: &VadData,
deg_vad: &VadData,
) -> Option<Split> {
let rate = reference.rate;
let window_samples = rate.window_samples();
let (start, end) = (work.start, work.end);
let (coarse, utterance_confidence) = (work.coarse, work.confidence);
let mut speech_start = start;
let mut speech_end = end;
while speech_start < speech_end && ref_vad.energy[speech_start] == 0.0 {
speech_start += 1;
}
while speech_end > start && ref_vad.energy[speech_end] == 0.0 {
speech_end -= 1;
}
speech_end += 1;
let speech_length = speech_end - speech_start;
if speech_length < MIN_SPLIT_SPEECH_WINDOWS {
return None;
}
let grid = split_grid_step(rate);
let step = (((0.801 * speech_length as f64 + 40.0 * grid as f64 - 1.0) / (40.0 * grid as f64))
.floor() as usize)
* grid;
let pad = (speech_length / 10).max(75);
let mut candidates = Vec::new();
let mut breakpoint = speech_start + pad;
while breakpoint <= speech_end.saturating_sub(pad) && candidates.len() < SPLIT_MAX_CANDIDATES {
candidates.push(breakpoint);
breakpoint += step;
}
if candidates.is_empty() {
return None;
}
let mut effective_window = hann_window(rate.align_fft_len());
let mut left_estimates = Vec::with_capacity(candidates.len());
let mut right_estimates = Vec::with_capacity(candidates.len());
for &candidate in &candidates {
match coarse_correlation(ref_vad, deg_vad, start, candidate, coarse, rate) {
Some((estimate, correlation)) => {
corrupt_window(&mut effective_window, &correlation, rate);
left_estimates.push(estimate);
}
None => left_estimates.push(coarse),
}
match coarse_correlation(ref_vad, deg_vad, candidate, end, coarse, rate) {
Some((estimate, correlation)) => {
corrupt_window(&mut effective_window, &correlation, rate);
right_estimates.push(estimate);
}
None => right_estimates.push(coarse),
}
}
let count = candidates.len();
let mut forward_delay = vec![0i32; count];
let mut forward_confidence = vec![0.0f32; count];
let mut computed = vec![false; count];
let mut i = 0;
while i < count {
let seed = left_estimates[i];
let mut pass = SplitAccumulator::new(
reference,
degraded,
start,
seed,
false,
&effective_window,
rate,
);
let mut j = i;
while j < count {
pass.advance_to(candidates[j] as i64 * window_samples as i64);
if left_estimates[j] == seed {
let (delay, confidence) = pass.record(seed);
forward_delay[j] = delay;
forward_confidence[j] = confidence;
computed[j] = true;
}
j += 1;
}
while i < count && computed[i] {
i += 1;
}
}
let mut backward_delay = vec![0i32; count];
let mut backward_confidence = vec![0.0f32; count];
let mut computed = vec![false; count];
let mut index = count;
loop {
let mut start_index = index;
let mut found = None;
while start_index > 0 {
start_index -= 1;
if !computed[start_index] && forward_confidence[start_index] > utterance_confidence {
found = Some(start_index);
break;
}
}
let Some(start_index) = found else {
break;
};
let seed = right_estimates[start_index];
let mut pass = SplitAccumulator::new(
reference,
degraded,
end,
seed,
true,
&effective_window,
rate,
);
let mut k = start_index;
loop {
pass.advance_to(candidates[k] as i64 * window_samples as i64);
if right_estimates[k] == seed
&& !computed[k]
&& forward_confidence[k] > utterance_confidence
{
let (delay, confidence) = pass.record(seed);
backward_delay[k] = delay;
backward_confidence[k] = confidence;
computed[k] = true;
}
if k == 0 {
break;
}
k -= 1;
}
index = start_index;
}
let mut best_index = None;
let mut best_sum = 0.0f32;
for i in 0..count {
let (fd, bd) = (forward_delay[i], backward_delay[i]);
if (fd - bd).abs() >= window_samples as i32
&& forward_confidence[i] > utterance_confidence
&& backward_confidence[i] > utterance_confidence
{
let sum = forward_confidence[i] + backward_confidence[i];
if best_index.is_none() || sum > best_sum {
best_index = Some(i);
best_sum = sum;
}
}
}
let i = best_index?;
Some(Split {
breakpoint: candidates[i],
left_estimate: left_estimates[i],
right_estimate: right_estimates[i],
forward_delay: forward_delay[i],
backward_delay: backward_delay[i],
forward_confidence: forward_confidence[i],
backward_confidence: backward_confidence[i],
})
}
struct SplitAccumulator<'a> {
reference: &'a [f32],
degraded: &'a [f32],
degraded_nominal: usize,
rate: Rate,
ref_cursor: i64,
deg_cursor: i64,
backward: bool,
window: Vec<f32>,
histogram: Vec<f32>,
hsum: f64,
frame_ref: Vec<f32>,
frame_deg: Vec<f32>,
}
impl<'a> SplitAccumulator<'a> {
fn new(
reference: &'a SignalBuffer,
degraded: &'a SignalBuffer,
boundary: usize,
seed: i32,
backward: bool,
window: &[f32],
rate: Rate,
) -> Self {
let window_samples = rate.window_samples() as i64;
let align_fft_len = rate.align_fft_len() as i64;
let mut ref_cursor = if backward {
boundary as i64 * window_samples - align_fft_len
} else {
boundary as i64 * window_samples
};
let mut deg_cursor = ref_cursor + i64::from(seed);
if backward {
if deg_cursor + align_fft_len > degraded.nominal_len as i64 {
deg_cursor = degraded.nominal_len as i64 - align_fft_len;
ref_cursor = deg_cursor - i64::from(seed);
}
} else if deg_cursor < 0 {
ref_cursor = i64::from(-seed);
deg_cursor = 0;
}
let align = rate.align_fft_len();
Self {
reference: &reference.samples,
degraded: °raded.samples,
degraded_nominal: degraded.nominal_len,
rate,
ref_cursor,
deg_cursor,
backward,
window: window.to_vec(),
histogram: vec![0.0f32; align],
hsum: 0.0,
frame_ref: vec![0.0f32; align],
frame_deg: vec![0.0f32; align],
}
}
}
impl SplitAccumulator<'_> {
fn advance_to(&mut self, candidate_samples: i64) {
loop {
let align = self.rate.align_fft_len() as i64;
let in_range = if self.backward {
self.deg_cursor >= 0 && self.ref_cursor >= candidate_samples
} else {
self.deg_cursor + align <= self.degraded_nominal as i64
&& self.ref_cursor + align <= candidate_samples
};
if !in_range {
return;
}
let align = self.rate.align_fft_len();
let ref_start = self.ref_cursor as usize;
let deg_start = self.deg_cursor as usize;
for i in 0..align {
self.frame_ref[i] = self.window[i] * self.reference[ref_start + i];
self.frame_deg[i] = self.window[i] * self.degraded[deg_start + i];
}
let spectrum = spectral_cross_correlate(&self.frame_ref, &self.frame_deg);
let peak = spectrum
.iter()
.map(|value| value.abs())
.fold(0.0f32, f32::max);
let radius = (self.rate.align_fft_len() / 64) as i32;
let v = 0.99 * peak;
let unit = v.powf(0.125) / radius as f32;
for (lag, &value) in spectrum.iter().enumerate() {
if value.abs() > v {
for k in -(radius - 1)..=radius - 1 {
let index =
(lag as i32 + k).rem_euclid(self.rate.align_fft_len() as i32) as usize;
self.histogram[index] += unit * (radius - k.unsigned_abs() as i32) as f32;
}
self.hsum += f64::from(v.powf(0.125));
}
}
let step = self.rate.align_fft_len() as i64 / 4;
if self.backward {
self.ref_cursor -= step;
self.deg_cursor -= step;
} else {
self.ref_cursor += step;
self.deg_cursor += step;
}
}
}
fn record(&mut self, seed: i32) -> (i32, f32) {
let mut peak_index = 0usize;
let mut peak_value = 0.0f32;
for (lag, &value) in self.histogram.iter().enumerate() {
if value > peak_value {
peak_value = value;
peak_index = lag;
}
}
let align = self.rate.align_fft_len();
let folded = if peak_index >= align / 2 {
peak_index as i32 - align as i32
} else {
peak_index as i32
};
let confidence = if self.hsum > 0.0 {
f64::from(peak_value) / self.hsum
} else {
0.0
} as f32;
(seed + folded, confidence)
}
}
fn corrupt_window(window: &mut [f32], correlation: &[f32], rate: Rate) {
let offset = scratch_window_offset(rate);
if correlation.len() <= offset {
return;
}
let reach = (correlation.len() - offset).min(window.len());
for (slot, &value) in window[..reach].iter_mut().zip(&correlation[offset..]) {
*slot = value;
}
}