msedge-tts

How to use

1. You need get a SpeechConfig to configure the voice of text to speech.
   You can convert Voice to SpeechConfig simply. Use get_voices_list function to get all available voices.
   Voice and SpeechConfig implemented serde::Serialize and serde::Deserialize.
   For example:

   use msedge_tts::voice::get_voices_list;
   use msedge_tts::tts::SpeechConfig;
   
   fn main() {
       let voices = get_voices_list().unwrap();
       let speechConfig = SpeechConfig::from(&voices[0]);
   }
   

   You can also create SpeechConfig by yourself. Make sure you know the right voice name and audio format.

2. Create a TTS Client or Stream. Both of them have sync and async version. Example below step 3.

3. Synthesize text to speech.

   Sync Client

   Call client function MSEdgeTTSClient::synthesize to synthesize text to speech. This function return Type SynthesizedAudio, you can get audio_bytes and audio_metadata.

   use msedge_tts::{tts::client::connect, tts::SpeechConfig, voice::get_voices_list};
   
   fn main() {
       let voices = get_voices_list().unwrap();
       for voice in &voices {
           if voice.name.contains("YunyangNeural") {
               let config = SpeechConfig::from(voice);
               let mut tts = connect().unwrap();
               let audio = tts
                   .synthesize("Hello, World! 你好，世界！", &config)
                   .unwrap();
               break;
           }
       }
   }
   

   Sync Stream

   Call Sender Stream function Sender::send to synthesize text to speech. Call Reader Stream function Receiver::read to get data.
   read return Option<SynthesizedResponse>, the response may be AudioBytes or AudioMetadata or None. This is because the MSEdge Read aloud API returns multiple data segment and metadata and other information sequentially.

   Caution: One send corresponds to multiple read. Next send call will block until there no data to read. read will block before you call a send.

   use msedge_tts::{
       tts::stream::{msedge_tts_split, SynthesizedResponse},
       tts::SpeechConfig,
       voice::get_voices_list,
   };
   use std::{
       sync::{
           atomic::{AtomicBool, Ordering},
           Arc,
       },
       thread::spawn,
   };
   
   fn main() {
       let voices = get_voices_list().unwrap();
       for voice in &voices {
           if voice.name.contains("YunyangNeural") {
               let config = SpeechConfig::from(voice);
               let (mut sender, mut reader) = msedge_tts_split().unwrap();
   
               let signal = Arc::new(AtomicBool::new(false));
               let end = signal.clone();
               spawn(move || {
                   sender.send("Hello, World! 你好，世界！", &config).unwrap();
                   println!("synthesizing...1");
                   sender.send("Hello, World! 你好，世界！", &config).unwrap();
                   println!("synthesizing...2");
                   sender.send("Hello, World! 你好，世界！", &config).unwrap();
                   println!("synthesizing...3");
                   sender.send("Hello, World! 你好，世界！", &config).unwrap();
                   println!("synthesizing...4");
                   end.store(true, Ordering::Relaxed);
               });
   
               loop {
                   if signal.load(Ordering::Relaxed) && !reader.can_read() {
                       break;
                   }
                   let audio = reader.read().unwrap();
                   if let Some(audio) = audio {
                       match audio {
                           SynthesizedResponse::AudioBytes(_) => {
                               println!("read bytes")
                           }
                           SynthesizedResponse::AudioMetadata(_) => {
                               println!("read metadata")
                           }
                       }
                   } else {
                       println!("read None");
                   }
               }
           }
       }
   }
   

See all examples.