use crate::kits::speech::asr::whisper::driver::whisper_token_layout::WhisperSpecialIds;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct TimedTokens {
pub start: usize,
pub end: usize,
pub tokens: Vec<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct WindowSplit {
pub segments: Vec<TimedTokens>,
pub advance: usize,
pub tail: Vec<i64>,
}
pub(crate) fn split_window(
tokens: &[i64],
ids: &WhisperSpecialIds,
count: usize,
frames_per_index: usize,
) -> WindowSplit {
let tb = ids.timestamp_begin;
let is_ts = |t: i64| t >= tb;
let frames = |t: i64| (t - tb) as usize * frames_per_index;
let n = tokens.len();
let single_timestamp_ending = n >= 2 && !is_ts(tokens[n - 2]) && is_ts(tokens[n - 1]);
let consecutive: Vec<usize> = (0..n.saturating_sub(1))
.filter(|&i| is_ts(tokens[i]) && is_ts(tokens[i + 1]))
.map(|i| i + 1)
.collect();
let (mut segments, advance, tail) = if !consecutive.is_empty() {
let mut slices = consecutive;
if single_timestamp_ending {
slices.push(n);
}
let mut segments = Vec::with_capacity(slices.len());
let mut last = 0;
for current in slices {
let sliced = &tokens[last..current];
segments.push(TimedTokens {
start: frames(sliced[0]),
end: frames(sliced[sliced.len() - 1]),
tokens: sliced.to_vec(),
});
last = current;
}
let advance = if single_timestamp_ending {
count
} else {
frames(tokens[last - 1])
};
(segments, advance, tokens[last..].to_vec())
} else {
let mut end = count;
if let Some(&last) = tokens.iter().rev().find(|&&t| is_ts(t))
&& last != tb
{
end = frames(last);
}
(
vec![TimedTokens {
start: 0,
end,
tokens: tokens.to_vec(),
}],
count,
Vec::new(),
)
};
segments.retain(|s| s.start != s.end && s.tokens.iter().any(|&t| t < ids.eot));
WindowSplit {
segments,
advance,
tail,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ids() -> WhisperSpecialIds {
WhisperSpecialIds::new(5, 1).unwrap()
}
fn ts(i: i64) -> i64 {
ids().timestamp_begin + i
}
#[test]
fn test_consecutive_pairs_split_and_seek_to_last_close() {
let ids = ids();
let tokens = vec![ts(0), 1, 2, ts(3), ts(3), 4, ts(6), ts(7), 1, 2];
let split = split_window(&tokens, &ids, 100, 2);
assert_eq!(
split.segments,
vec![
TimedTokens {
start: 0,
end: 6,
tokens: vec![ts(0), 1, 2, ts(3)],
},
TimedTokens {
start: 6,
end: 12,
tokens: vec![ts(3), 4, ts(6)],
},
]
);
assert_eq!(split.advance, 12, "to the last closed timestamp, in frames");
assert_eq!(split.tail, vec![ts(7), 1, 2]);
}
#[test]
fn test_single_timestamp_ending_takes_the_whole_window() {
let ids = ids();
let tokens = vec![ts(0), 1, ts(2), ts(2), 3, ts(5)];
let split = split_window(&tokens, &ids, 100, 2);
assert_eq!(split.segments.len(), 2);
assert_eq!(split.segments[1].tokens, vec![ts(2), 3, ts(5)]);
assert_eq!((split.segments[1].start, split.segments[1].end), (4, 10));
assert_eq!(split.advance, 100);
assert!(split.tail.is_empty());
}
#[test]
fn test_no_pairs_is_one_segment() {
let ids = ids();
let split = split_window(&[ts(1), 2, 3, ts(4)], &ids, 100, 2);
assert_eq!(
split.segments,
vec![TimedTokens {
start: 0,
end: 8,
tokens: vec![ts(1), 2, 3, ts(4)],
}]
);
assert_eq!(split.advance, 100);
let split = split_window(&[2, 3], &ids, 40, 2);
assert_eq!((split.segments[0].start, split.segments[0].end), (0, 40));
assert_eq!(split.advance, 40);
let split = split_window(&[ts(0), 2, 3, ts(0)], &ids, 40, 2);
assert_eq!(split.segments[0].end, 40);
}
#[test]
fn test_empty_and_textless_are_dropped() {
let ids = ids();
let split = split_window(&[], &ids, 40, 2);
assert!(split.segments.is_empty());
assert_eq!(split.advance, 40);
let split = split_window(&[ts(0), ts(3), ts(3), 4, ts(5), ts(6)], &ids, 40, 2);
assert_eq!(
split.segments.len(),
1,
"the textless first pair is dropped"
);
assert_eq!(split.segments[0].tokens, vec![ts(3), 4, ts(5)]);
assert_eq!(split.advance, 10);
assert_eq!(split.tail, vec![ts(6)]);
let split = split_window(&[ts(2), 4, ts(2), ts(2), 4, ts(5), ts(5)], &ids, 40, 2);
assert_eq!(split.segments.len(), 1);
assert_eq!(split.segments[0].start, 4);
}
#[test]
fn test_reference_window_shape() {
let ids = WhisperSpecialIds::from_vocab_size(51865).unwrap();
let tb = ids.timestamp_begin;
let tokens = vec![
tb + 0,
264,
7135,
13,
tb + 388,
tb + 388,
1545,
tb + 440,
tb + 440,
492,
tb + 948,
tb + 1268,
];
let split = split_window(&tokens, &ids, 3000, 2);
assert_eq!(split.segments.len(), 3);
assert_eq!((split.segments[0].start, split.segments[0].end), (0, 776));
assert_eq!((split.segments[1].start, split.segments[1].end), (776, 880));
assert_eq!(
(split.segments[2].start, split.segments[2].end),
(880, 1896)
);
assert_eq!(split.advance, 1896);
assert_eq!(split.tail, vec![tb + 1268]);
}
}