feat(server): add mute tts model

Author: lastsunday

apps/server/api/src/config/mod.rs

@@ -484,6 +484,7 @@ pub enum TtsModel {
     #[default]
     Kokoro,
     Voxcpm,
+    Mute,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Default)]

apps/server/api/src/tts/mod.rs

@@ -5,6 +5,7 @@ use crate::common::ModelError;
 use crate::config;
 use crate::config::audio::AudioConfig;
 use crate::config::tts::TtsConfig;
+use crate::tts::model::mute::TtsMute;
 use async_trait::async_trait;
 use futures::Stream;
 use model::kokoro::TtsKokoro;
@@ -23,7 +24,7 @@ pub trait Tts: Send + Sync {
 }
 
 pub struct TtsData {
-    pub audio: Vec<Vec<u8>>,
+    pub audio: Option<Vec<Vec<u8>>>,
     pub text: String,
 }
 
@@ -107,6 +108,7 @@ impl TtsFactory {
                 )
                 .await?,
             )),
+            config::TtsModel::Mute => Ok(Box::new(TtsMute::new().await?)),
         }
     }
 

apps/server/api/src/tts/model/kokoro/mod.rs

@@ -81,7 +81,7 @@ impl Tts for TtsKokoro {
                                         encode_frame_duration,
                                     );
                                     let data = TtsData {
-                                        audio,
+                                        audio: Some(audio),
                                         text: text.to_string(),
                                     };
                                     if let Err(e) = tx.send(Ok(data)).await {

apps/server/api/src/tts/model/mod.rs

@@ -1,2 +1,3 @@
 pub mod kokoro;
+pub mod mute;
 pub mod voxcpm;

apps/server/api/src/tts/model/mute/mod.rs

@@ -0,0 +1,63 @@
+use crate::common::ModelError;
+use crate::tts::{Tts, TtsData, TtsError};
+use async_trait::async_trait;
+use futures::Stream;
+use futures::executor::block_on;
+use std::pin::Pin;
+use std::thread;
+use tokio::sync::mpsc::channel;
+use tokio_stream::StreamExt;
+use tokio_stream::wrappers::ReceiverStream;
+use tracing::{debug, error};
+
+pub struct TtsMute {}
+
+impl TtsMute {
+    pub async fn new() -> Result<Self, anyhow::Error> {
+        Ok(Self {})
+    }
+}
+
+#[async_trait]
+impl Tts for TtsMute {
+    async fn stream(
+        &self,
+        mut text_stream: Pin<
+            Box<dyn Stream<Item = core::result::Result<String, ModelError>> + Send + Sync>,
+        >,
+    ) -> Pin<Box<dyn Stream<Item = core::result::Result<TtsData, TtsError>> + Send + Sync>> {
+        let (tx, rx) = channel(10);
+        thread::spawn(move || {
+            block_on(async move {
+                while let Some(text) = text_stream.next().await {
+                    // let instance = instance.clone();
+                    let tx = tx.clone();
+                    match &text {
+                        Ok(text) => {
+                            debug!("[TTS] receive, text = {}", text);
+                            let data = TtsData {
+                                audio: None,
+                                text: text.to_string(),
+                            };
+                            if let Err(e) = tx.send(Ok(data)).await {
+                                error!("output packet error = {}", e);
+                                break;
+                            } else {
+                                debug!("[TTS] encode and send audio success");
+                            }
+                        }
+                        Err(e) => {
+                            error!("tts text stream error = {}", e.to_string());
+                            if let Err(e) = tx.send(Err(TtsError::Text(e.to_string()))).await {
+                                error!("send error failure = {}", e);
+                            }
+                            break;
+                        }
+                    }
+                }
+                drop(tx);
+            })
+        });
+        Box::pin(ReceiverStream::new(rx))
+    }
+}

apps/server/api/src/tts/model/voxcpm/mod.rs

@@ -94,7 +94,7 @@ impl Tts for TtsVoxCPM {
                                                 encode_frame_duration,
                                             );
                                             let data = TtsData {
-                                                audio,
+                                                audio: Some(audio),
                                                 text: text.to_string(),
                                             };
                                             if let Err(e) = tx.send(Ok(data)).await {

apps/server/api/src/ws/session/round.rs

@@ -210,6 +210,7 @@ impl Round {
                             .await?;
                             //audio
                             //real time send audio
+                            let audio_data = audio_data.unwrap_or_default();
                             let data = audio_data.into_iter();
                             speaking.store(true, Ordering::Relaxed);
                             debug!("set speaking = true");