use crate::kits::speech::asr::driver::{
TimedTokens,
WindowDecode,
};
impl<C> WindowDecode<C> {
pub fn from_words(
words: &[WordSpan],
tokens: Vec<i64>,
frames: usize,
window_frames: usize,
grid: usize,
carry: C,
) -> Self {
let cut = (frames >= window_frames)
.then(|| pause_cut(words, frames, grid))
.flatten();
let (advance, count) = cut.unwrap_or((frames, words.len()));
let committed = words.get(count).map_or(tokens.len(), |w| w.first_token);
Self {
segments: word_segments(&words[..count], &tokens[..committed], advance),
tail: cut.map(|(cut, _)| TimedTokens {
start: cut,
end: frames,
tokens: tokens[committed..].to_vec(),
}),
skip: tokens.is_empty(),
tokens,
advance,
carry,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct WordSpan {
pub first_token: usize,
pub start: usize,
pub end: usize,
}
pub fn pause_cut(
words: &[WordSpan],
frames: usize,
grid: usize,
) -> Option<(usize, usize)> {
let late = frames * 2 / 3;
let pause = |i: usize| {
let end = words[i - 1].end;
(words[i].start.saturating_sub(end), end)
};
let (i, mid) = (1..words.len())
.map(|i| {
let (gap, end) = pause(i);
(i, gap, end + gap / grid / 2 * grid)
})
.filter(|&(i, gap, _)| gap > 0 && words[i].start >= late)
.max_by_key(|&(_, gap, _)| gap)
.map(|(i, _, mid)| (i, mid))
.or_else(|| {
let i = words.len().checked_sub(1).filter(|&i| i > 0)?;
Some((i, pause(i).1))
})?;
let cut = mid.min(frames);
(cut > 0).then_some((cut, i))
}
pub fn word_segments(
words: &[WordSpan],
tokens: &[i64],
limit: usize,
) -> Vec<TimedTokens> {
words
.iter()
.enumerate()
.map(|(i, word)| {
let next = words.get(i + 1);
let start = word.start.min(limit);
let bound = next.map_or(limit, |n| n.start.min(limit));
TimedTokens {
start,
end: word.end.min(bound).max(start),
tokens: tokens[word.first_token..next.map_or(tokens.len(), |n| n.first_token)]
.to_vec(),
}
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn span(
first_token: usize,
start: usize,
end: usize,
) -> WordSpan {
WordSpan {
first_token,
start,
end,
}
}
#[test]
fn test_pause_cut() {
let words = [
span(0, 16, 24),
span(1, 40, 56),
span(3, 144, 152),
span(4, 160, 168),
];
assert_eq!(pause_cut(&words, 100 * 2, 8), Some((96, 2)));
assert_eq!(pause_cut(&words, 200, 1), Some((100, 2)));
let even = [
span(0, 0, 140),
span(1, 150, 160),
span(2, 170, 180),
span(3, 190, 195),
];
assert_eq!(pause_cut(&even, 200, 1), Some((185, 3)));
let packed = [span(0, 0, 50), span(1, 50, 120), span(2, 120, 190)];
assert_eq!(pause_cut(&packed, 200, 1), Some((120, 2)));
assert_eq!(pause_cut(&[span(0, 0, 50)], 200, 1), None);
assert_eq!(pause_cut(&[span(0, 0, 0), span(1, 0, 4)], 200, 1), None);
}
#[test]
fn test_word_segments() {
let words = [span(0, 16, 48), span(2, 40, 56), span(3, 60, 90)];
let tokens = [7, 8, 9, 10, 11];
assert_eq!(
word_segments(&words, &tokens, 80),
[
TimedTokens {
start: 16,
end: 40,
tokens: vec![7, 8],
},
TimedTokens {
start: 40,
end: 56,
tokens: vec![9],
},
TimedTokens {
start: 60,
end: 80,
tokens: vec![10, 11],
},
]
);
assert!(word_segments(&[], &[], 10).is_empty());
}
}