use crate::{
errors::BunsenResult,
kits::speech::diarization::{
SpeakerActivity,
SpeakerActivityModel,
SpeakerActivityStream,
},
};
#[derive(Clone, Debug)]
pub struct ScriptedDiarizer {
pub sample_rate: usize,
pub frame_samples: usize,
pub n_speakers: usize,
pub latency: usize,
pub script: Vec<(usize, Option<usize>)>,
}
impl ScriptedDiarizer {
pub fn speaker_at(
&self,
sample: usize,
) -> Option<usize> {
self.script
.iter()
.rev()
.find(|(from, _)| *from <= sample)
.and_then(|&(_, who)| who)
}
}
impl SpeakerActivityModel for ScriptedDiarizer {
fn sample_rate(&self) -> usize {
self.sample_rate
}
fn frame_samples(&self) -> usize {
self.frame_samples
}
fn max_speakers(&self) -> usize {
self.n_speakers
}
fn new_stream(&self) -> BunsenResult<Box<dyn SpeakerActivityStream>> {
Ok(Box::new(ScriptedStream {
diarizer: self.clone(),
seen: 0,
emitted: 0,
}))
}
}
#[derive(Clone, Debug)]
struct ScriptedStream {
diarizer: ScriptedDiarizer,
seen: usize,
emitted: usize,
}
impl ScriptedStream {
fn frames(
&mut self,
upto: usize,
) -> BunsenResult<SpeakerActivity> {
let d = &self.diarizer;
let start = self.emitted * d.frame_samples;
let mut probs = Vec::new();
for f in self.emitted..upto {
let who = d.speaker_at(f * d.frame_samples);
probs.extend((0..d.n_speakers).map(|k| if who == Some(k) { 0.9 } else { 0.05 }));
}
self.emitted = upto.max(self.emitted);
SpeakerActivity::try_new(start, d.frame_samples, d.n_speakers, probs)
}
}
impl SpeakerActivityStream for ScriptedStream {
fn push(
&mut self,
samples: &[f32],
) -> BunsenResult<SpeakerActivity> {
self.seen += samples.len();
let upto = self.seen.saturating_sub(self.diarizer.latency) / self.diarizer.frame_samples;
self.frames(upto)
}
fn finish(&mut self) -> BunsenResult<SpeakerActivity> {
let upto = self.seen.div_ceil(self.diarizer.frame_samples);
self.frames(upto)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_follows_its_script() {
let d = ScriptedDiarizer {
sample_rate: 100,
frame_samples: 10,
n_speakers: 2,
latency: 15,
script: vec![(0, Some(0)), (30, None), (50, Some(1))],
};
assert_eq!(d.speaker_at(29), Some(0));
assert_eq!(d.speaker_at(30), None);
assert_eq!(d.speaker_at(77), Some(1));
let mut stream = d.new_stream().unwrap();
let mut a = stream.push(&[0.0; 45]).unwrap();
assert_eq!(a.frames(), 3);
a.append(stream.push(&[0.0; 30]).unwrap()).unwrap();
a.append(stream.finish().unwrap()).unwrap();
assert_eq!(a.frames(), 8);
assert_eq!(a.frame(0), [0.9, 0.05]);
assert_eq!(a.frame(3), [0.05, 0.05]);
assert_eq!(a.frame(7), [0.05, 0.9]);
}
}