use std::sync::Arc;
use crate::{
errors::{
BunsenError,
BunsenResult,
ConstraintError,
Rule,
},
kits::speech::asr_driver::{
AsrEngine,
AsrStreamContext,
CommitRule,
EmissionPolicy,
LevelPolicy,
StreamClock,
VoiceActivityFilterConfig,
VoiceActivityModel,
},
};
#[derive(Clone, Debug)]
pub struct AsrStreamDriver<E: AsrEngine> {
engine: E,
emission: EmissionPolicy,
vad: Option<Arc<dyn VoiceActivityModel>>,
va_filter: Option<VoiceActivityFilterConfig>,
}
impl<E: AsrEngine> AsrStreamDriver<E> {
pub fn new(
engine: E,
emission: EmissionPolicy,
) -> BunsenResult<Self> {
Self::check_emission(&emission)?;
Ok(Self {
engine,
emission,
vad: None,
va_filter: None,
})
}
fn check_emission(emission: &EmissionPolicy) -> BunsenResult<()> {
let triggers = &emission.triggers;
if !triggers.window_full && !triggers.endpoint {
return Err(BunsenError::illegal(
"EmissionPolicy.triggers: with neither the window_full nor the endpoint \
trigger nothing would ever decode",
));
}
if triggers.interval.is_some_and(|i| i.is_zero()) {
return Err(BunsenError::from(ConstraintError::zero_or_empty(
"EmissionPolicy",
"triggers.interval",
))
.with_details("an interval of zero would draft on every push"));
}
if triggers.interval.is_some() && !triggers.endpoint {
return Err(BunsenError::illegal(
"EmissionPolicy.triggers: the interval trigger drafts only while speech is in \
progress, which only the endpoint trigger's voice-activity gate tracks; turn \
endpoint on as well",
));
}
if let CommitRule::Agreement { .. } = emission.commit {
return Err(BunsenError::unsupported(
"EmissionPolicy.commit: the Agreement commit rule is not implemented; use \
Complete or LastTimestamp",
));
}
Ok(())
}
pub fn with_vad(
mut self,
vad: Arc<dyn VoiceActivityModel>,
filter: VoiceActivityFilterConfig,
) -> BunsenResult<Self> {
self.check_vad(vad.as_ref(), &filter)?;
self.vad = Some(vad);
self.va_filter = Some(filter);
Ok(self)
}
fn check_vad(
&self,
vad: &dyn VoiceActivityModel,
filter: &VoiceActivityFilterConfig,
) -> BunsenResult<()> {
let rate = self.sample_rate();
if vad.sample_rate() != rate {
return Err(must_equal(
("vad.sample_rate()", vad.sample_rate()),
("the driver's sample_rate()", rate),
));
}
if filter.sample_rate != rate {
return Err(must_equal(
("filter.sample_rate", filter.sample_rate),
("the driver's sample_rate()", rate),
));
}
if filter.samples_per_chunk != vad.chunk_size() {
return Err(must_equal(
("filter.samples_per_chunk", filter.samples_per_chunk),
("vad.chunk_size()", vad.chunk_size()),
));
}
Ok(())
}
pub fn engine(&self) -> &E {
&self.engine
}
pub fn map_engine(
mut self,
f: impl FnOnce(E) -> E,
) -> Self {
self.engine = f(self.engine);
self
}
pub fn emission(&self) -> &EmissionPolicy {
&self.emission
}
pub fn vad(&self) -> Option<&Arc<dyn VoiceActivityModel>> {
self.vad.as_ref()
}
pub fn va_filter_config(&self) -> Option<&VoiceActivityFilterConfig> {
self.va_filter.as_ref()
}
pub fn sample_rate(&self) -> usize {
self.engine.sample_rate()
}
pub fn interval_samples(&self) -> Option<usize> {
self.emission
.triggers
.interval
.map(|i| (i.as_secs_f64() * self.sample_rate() as f64).round() as usize)
}
pub fn grid_samples(&self) -> usize {
self.engine.grid_frames() * self.engine.hop()
}
pub fn new_context(
&self,
clock: StreamClock,
level: LevelPolicy,
) -> BunsenResult<AsrStreamContext<E>> {
if clock.rate() != self.sample_rate() {
return Err(ConstraintError::new(
"AsrStreamDriver::new_context",
"",
Rule::Relation {
lhs: ("clock.rate()".into(), clock.rate().to_string()),
op: "==",
rhs: (
"the engine's sample_rate()".into(),
self.sample_rate().to_string(),
),
},
)
.into());
}
if self.emission.triggers.endpoint && self.vad.is_none() {
return Err(BunsenError::illegal(
"the endpoint trigger needs a voice-activity model; attach one with with_vad",
));
}
AsrStreamContext::init(self.clone(), clock, level)
}
}
fn must_equal(
lhs: (&str, usize),
rhs: (&str, usize),
) -> BunsenError {
ConstraintError::new(
"AsrStreamDriver::with_vad",
"",
Rule::Relation {
lhs: (lhs.0.into(), lhs.1.to_string()),
op: "==",
rhs: (rhs.0.into(), rhs.1.to_string()),
},
)
.into()
}