use std::{
collections::BTreeMap,
sync::Arc,
};
use bunsen::{
data::{
builds::BuildProvider,
catalog::{
CatalogName,
resolve::ResolvedBuild,
},
formats::LoadPolicy,
resources::ResourceCache,
},
errors::{
BunsenError,
BunsenResult,
LookupError,
},
kits::{
speech::tts::{
driver::{
TtsDriver,
TtsDriverConfig,
TtsSynthesizer,
},
qwen3_tts::{
driver::{
Qwen3TtsEngine,
Qwen3TtsEngineConfig,
},
pretrained::{
DEFAULT_QWEN3_TTS_MODEL,
default_qwen3_tts_factory,
},
prompt::Qwen3TtsTextPlacement,
},
zonos3::{
driver::{
Zonos3Engine,
zonos3_release_normalization,
},
pretrained::{
DEFAULT_ZONOS3_MODEL,
default_zonos3_factory,
},
},
},
support::{
text::TextNormalizationConfig,
tokens::BunsenTokenizer,
},
},
};
use burn::tensor::Device;
#[derive(clap::ValueEnum, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum TtsFamily {
Zonos3,
#[value(name = "qwen3-tts")]
Qwen3Tts,
}
impl TtsFamily {
pub const ALL: [Self; 2] = [Self::Zonos3, Self::Qwen3Tts];
pub fn name(self) -> &'static str {
match self {
Self::Zonos3 => "zonos3",
Self::Qwen3Tts => "qwen3-tts",
}
}
pub fn default_model(self) -> &'static str {
match self {
Self::Zonos3 => DEFAULT_ZONOS3_MODEL,
Self::Qwen3Tts => DEFAULT_QWEN3_TTS_MODEL,
}
}
pub fn release_normalization(self) -> TextNormalizationConfig {
match self {
Self::Zonos3 => zonos3_release_normalization(),
Self::Qwen3Tts => TextNormalizationConfig::None,
}
}
pub fn rows(self) -> BunsenResult<Vec<(String, ResolvedBuild)>> {
Ok(match self {
Self::Zonos3 => default_zonos3_factory()?.list(),
Self::Qwen3Tts => default_qwen3_tts_factory()?.list(),
})
}
pub fn providers(self) -> BunsenResult<Vec<Arc<dyn BuildProvider>>> {
Ok(match self {
Self::Zonos3 => default_zonos3_factory()?.providers().to_vec(),
Self::Qwen3Tts => default_qwen3_tts_factory()?.providers().to_vec(),
})
}
pub fn knows(
self,
name: &str,
) -> BunsenResult<bool> {
Ok(match self {
Self::Zonos3 => default_zonos3_factory()?.lookup(name).is_ok(),
Self::Qwen3Tts => default_qwen3_tts_factory()?.lookup(name).is_ok(),
})
}
pub fn fetch(
self,
name: &str,
cache: &ResourceCache,
) -> BunsenResult<(String, Vec<(String, std::path::PathBuf)>)> {
let fetched = |id: String, map| -> BunsenResult<_> {
let loaded = cache.load(&map)?;
let parts = loaded
.iter()
.map(|(key, part)| (key.to_string(), part.path.clone()))
.collect();
Ok((id, parts))
};
match self {
Self::Zonos3 => {
let model = default_zonos3_factory()?.resolve(name, cache)?;
fetched(model.id().to_string(), model.plan(cache)?)
}
Self::Qwen3Tts => {
let model = default_qwen3_tts_factory()?.resolve(name, cache)?;
fetched(model.id().to_string(), model.plan(cache)?)
}
}
}
pub fn load(
self,
model: &str,
cache: &ResourceCache,
device: &Device,
policy: LoadPolicy,
driver: TtsDriverConfig,
flags: &TtsFamilyArgs,
) -> BunsenResult<Arc<dyn TtsSynthesizer>> {
flags.check(self)?;
match self {
Self::Zonos3 => {
let construct =
default_zonos3_factory()?.load_construct(model, cache, device, policy)?;
let tokenizer = BunsenTokenizer::from_file(&construct.tokenizer)?;
let mut config = construct
.engine_config
.clone()
.with_conditions(flags.condition_values()?);
if let Some(frames) = flags.silence_prefill_frames {
config.silence_prefill_frames = frames;
}
let engine = Zonos3Engine::new(construct, tokenizer, config)?;
Ok(Arc::new(TtsDriver::new(engine, driver)?))
}
Self::Qwen3Tts => {
let construct =
default_qwen3_tts_factory()?.load_construct(model, cache, device, policy)?;
let tokenizer = construct.tokenizer.load()?;
let mut config = Qwen3TtsEngineConfig::new();
if let Some(placement) = flags.placement {
config.placement = match placement {
TtsPlacement::Upfront => Qwen3TtsTextPlacement::Upfront,
TtsPlacement::Interleaved => Qwen3TtsTextPlacement::Interleaved,
};
}
let mut take = construct.take.clone();
let predictor = &mut take.code_predictor;
if let Some(t) = flags.predictor_temperature {
predictor.temperature = t;
predictor.sample = t > 0.0;
}
if let Some(k) = flags.predictor_top_k {
predictor.top_k = k;
}
if let Some(p) = flags.predictor_top_p {
predictor.top_p = p;
}
config.take = Some(take);
let engine = Qwen3TtsEngine::new(construct, tokenizer, config)?;
Ok(Arc::new(TtsDriver::new(engine, driver)?))
}
}
}
}
#[derive(clap::ValueEnum, Clone, Copy, Debug, PartialEq, Eq)]
pub enum TtsPlacement {
Upfront,
Interleaved,
}
#[derive(clap::Args, Clone, Debug, Default)]
pub struct TtsFamilyArgs {
#[arg(long = "condition", value_name = "NAME=VALUE")]
pub conditions: Vec<String>,
#[arg(long)]
pub silence_prefill_frames: Option<usize>,
#[arg(long, value_enum)]
pub placement: Option<TtsPlacement>,
#[arg(long)]
pub predictor_temperature: Option<f64>,
#[arg(long)]
pub predictor_top_k: Option<usize>,
#[arg(long)]
pub predictor_top_p: Option<f64>,
}
impl TtsFamilyArgs {
fn given(&self) -> Vec<(&'static str, TtsFamily)> {
let z = TtsFamily::Zonos3;
let q = TtsFamily::Qwen3Tts;
[
("--condition", !self.conditions.is_empty(), z),
(
"--silence-prefill-frames",
self.silence_prefill_frames.is_some(),
z,
),
("--placement", self.placement.is_some(), q),
(
"--predictor-temperature",
self.predictor_temperature.is_some(),
q,
),
("--predictor-top-k", self.predictor_top_k.is_some(), q),
("--predictor-top-p", self.predictor_top_p.is_some(), q),
]
.into_iter()
.filter(|(_, given, _)| *given)
.map(|(flag, _, family)| (flag, family))
.collect()
}
pub fn check(
&self,
family: TtsFamily,
) -> BunsenResult<()> {
match self.given().into_iter().find(|(_, of)| *of != family) {
Some((flag, of)) => Err(BunsenError::illegal(format!(
"{flag} is a {} flag; the checkpoint is a {}",
of.name(),
family.name()
))),
None => Ok(()),
}
}
pub fn condition_values(&self) -> BunsenResult<BTreeMap<String, f64>> {
let mut values = BTreeMap::new();
for spec in &self.conditions {
let (name, value) = spec.split_once('=').ok_or_else(|| {
BunsenError::illegal(format!("--condition {spec:?}: not NAME=VALUE"))
})?;
let value: f64 = value.trim().parse().map_err(|_| {
BunsenError::illegal(format!("--condition {spec:?}: {value:?} is not a number"))
})?;
if values.insert(name.trim().to_string(), value).is_some() {
return Err(BunsenError::illegal(format!(
"--condition {name} given twice"
)));
}
}
Ok(values)
}
}
pub fn tts_builds() -> BunsenResult<Vec<(CatalogName, TtsFamily)>> {
let mut builds = Vec::new();
for family in TtsFamily::ALL {
for (_, row) in family.rows()? {
builds.push((row.name, family));
}
}
Ok(builds)
}
pub fn tts_family_of(model: &str) -> BunsenResult<TtsFamily> {
for family in TtsFamily::ALL {
if family.knows(model)? {
return Ok(family);
}
}
Err(BunsenError::lookup(
LookupError::missing("TTS checkpoint", model)
.with_candidates(TtsFamily::ALL.iter().map(|f| f.name())),
)
.with_details("a provider ref names no family: pass --family"))
}
#[cfg(test)]
mod tests {
use bunsen::errors::BunsenErrorKind;
use clap::Parser;
use super::*;
#[derive(Parser, Debug)]
struct Cli {
#[command(flatten)]
flags: TtsFamilyArgs,
}
fn flags(argv: &[&str]) -> TtsFamilyArgs {
Cli::try_parse_from([&["tts"], argv].concat())
.unwrap()
.flags
}
#[test]
fn test_check() {
let zonos3 = flags(&[
"--condition",
"speaking_rate=14",
"--silence-prefill-frames",
"2",
]);
zonos3.check(TtsFamily::Zonos3).unwrap();
let error = zonos3.check(TtsFamily::Qwen3Tts).unwrap_err();
assert_eq!(error.kind(), BunsenErrorKind::Illegal);
assert!(
error.to_string().contains("--condition is a zonos3 flag"),
"{error}"
);
let qwen = flags(&["--placement", "interleaved", "--predictor-top-k", "20"]);
qwen.check(TtsFamily::Qwen3Tts).unwrap();
assert!(qwen.check(TtsFamily::Zonos3).is_err());
TtsFamilyArgs::default().check(TtsFamily::Zonos3).unwrap();
}
#[test]
fn test_condition_values() {
let values = flags(&[
"--condition",
"loudness=-20",
"--condition",
" fmax = 12000",
])
.condition_values()
.unwrap();
assert_eq!(
values,
BTreeMap::from([
("fmax".to_string(), 12000.0),
("loudness".to_string(), -20.0)
])
);
for bad in [["--condition", "loud"], ["--condition", "loud=x"]] {
assert!(flags(&bad).condition_values().is_err(), "{bad:?}");
}
let twice = flags(&["--condition", "a=1", "--condition", "a=2"]);
assert!(twice.condition_values().is_err());
}
}