use std::sync::Arc;
use bunsen::{
data::{
formats::LoadPolicy,
resources::ResourceCache,
},
errors::{
BunsenError,
BunsenResult,
},
kits::speech::{
asr::driver::{
AsrEngine,
AsrStreamContext,
AsrStreamDriver,
EmissionMode,
EmissionPolicy,
MeanActivity,
StreamClock,
TranscriptEvent,
TranscriptSegment,
},
diarization::SpeakerActivityModel,
vad::silero_vad::pretrained::default_silero_factory,
},
};
use burn::tensor::Device;
use crate::asr::construct_config;
#[derive(clap::ValueEnum, Clone, Copy, Debug, PartialEq, Eq, serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Emission {
Offline,
Conservative,
Drafting,
}
impl Emission {
pub fn name(self) -> &'static str {
match self {
Emission::Offline => "offline",
Emission::Conservative => "conservative",
Emission::Drafting => "drafting",
}
}
}
impl From<Emission> for EmissionPolicy {
fn from(emission: Emission) -> Self {
match emission {
Emission::Offline => EmissionMode::Offline,
Emission::Conservative => EmissionMode::Conservative,
Emission::Drafting => EmissionMode::Drafting,
}
.into()
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Streaming {
pub emission: Emission,
pub vad: Option<String>,
pub chunk_ms: usize,
}
#[derive(clap::Args, Clone, Debug, Default)]
pub struct VadArgs {
#[arg(long, value_name = "EXPR")]
pub vad: Option<String>,
}
impl VadArgs {
pub fn slot(
&self,
emission: Emission,
) -> BunsenResult<Option<String>> {
match (emission, &self.vad) {
(Emission::Offline, Some(_)) => Err(BunsenError::policy(
"`--vad` has no effect with `--emission offline`",
)),
(Emission::Offline, None) => Ok(None),
(_, Some(vad)) => Ok(Some(vad.clone())),
(_, None) => Ok(Some(construct_config().vad.clone())),
}
}
}
pub fn with_vad<E: AsrEngine>(
driver: AsrStreamDriver<E>,
vad: Option<&str>,
cache: &ResourceCache,
device: &Device,
policy: LoadPolicy,
) -> BunsenResult<AsrStreamDriver<E>> {
let Some(vad) = vad else {
return Ok(driver);
};
let vad = default_silero_factory()?
.load(vad, cache, device, policy)?
.handle;
let rate = driver.sample_rate();
driver.with_vad(
Arc::new(vad.expect_branch(rate).clone()),
vad.vad_filter().clone(),
)
}
pub fn with_speakers<E: AsrEngine>(
driver: AsrStreamDriver<E>,
speakers: Option<Arc<dyn SpeakerActivityModel>>,
) -> BunsenResult<AsrStreamDriver<E>> {
match speakers {
Some(model) => driver.with_speakers(model, Arc::new(MeanActivity::default())),
None => Ok(driver),
}
}
pub fn push_samples<E: AsrEngine>(
driver: &AsrStreamDriver<E>,
ms: usize,
) -> usize {
let mut grain = driver.grid_samples();
if let Some(vad) = driver.vad() {
grain = lcm(grain, vad.chunk_size());
}
(ms * driver.sample_rate())
.div_ceil(1000)
.div_ceil(grain)
.max(1)
* grain
}
pub fn open<E: AsrEngine>(driver: &AsrStreamDriver<E>) -> BunsenResult<AsrStreamContext<E>> {
driver.new_context(
StreamClock::uniform(driver.sample_rate()),
driver.engine().level_policy(),
)
}
pub fn stream<E: AsrEngine>(
driver: &AsrStreamDriver<E>,
samples: &[f32],
chunk: usize,
) -> BunsenResult<(Vec<TranscriptSegment>, AsrStreamContext<E>)> {
let mut ctx = open(driver)?;
let mut segments = Vec::new();
let mut keep = |events: Vec<TranscriptEvent>| {
segments.extend(events.into_iter().filter_map(|e| match e {
TranscriptEvent::Committed(segment) => Some(segment),
TranscriptEvent::Draft(_) => None,
}))
};
for block in samples.chunks(chunk) {
keep(ctx.write_read(block)?);
}
keep(ctx.end_read()?);
Ok((segments, ctx))
}
pub fn join_text(segments: &[TranscriptSegment]) -> String {
segments
.iter()
.filter_map(|s| s.text.as_deref().map(str::trim))
.filter(|t| !t.is_empty())
.collect::<Vec<_>>()
.join(" ")
}
fn gcd(
a: usize,
b: usize,
) -> usize {
if b == 0 { a } else { gcd(b, a % b) }
}
fn lcm(
a: usize,
b: usize,
) -> usize {
a / gcd(a, b) * b
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_lcm() {
assert_eq!(lcm(160, 320), 320);
assert_eq!(lcm(320, 512), 2560);
}
#[test]
fn test_join_text() {
let segment = |text: Option<&str>| TranscriptSegment {
start: 0.0,
end: 0.0,
tokens: Vec::new(),
text: text.map(String::from),
speaker: None,
};
let segments = [
segment(Some(" the")),
segment(None),
segment(Some(" ")),
segment(Some("moon. ")),
];
assert_eq!(join_text(&segments), "the moon.");
}
}