msedge-tts 0.4.0

This library is a wrapper of MSEdge Read aloud function API. You can use it to synthesize text to speech with many voices MS provided.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! TTS Client module

use crate::tts::AudioMetadata;

/// Synthesized Audio and Metadata
#[derive(Debug)]
pub struct SynthesizedAudio {
    pub audio_format: String,
    pub audio_bytes: Vec<u8>,
    pub audio_metadata: Vec<AudioMetadata>,
}

/// Async Client
#[cfg(any(feature = "smol-runtime", feature = "tokio-runtime"))]
#[cfg_attr(
    docsrs,
    doc(cfg(any(feature = "smol-runtime", feature = "tokio-runtime")))
)]
pub struct MSEdgeTTSClientAsync<T>(pub(crate) async_tungstenite::WebSocketStream<T>);

#[cfg(any(feature = "smol-runtime", feature = "tokio-runtime"))]
impl<T: futures_util::io::AsyncRead + futures_util::io::AsyncWrite + Unpin>
    MSEdgeTTSClientAsync<T>
{
    /// Synthesize text to speech with a [crate::tts::SpeechConfig] asynchronously
    pub async fn synthesize(
        &mut self,
        text: &str,
        config: &crate::tts::SpeechConfig,
    ) -> crate::error::Result<SynthesizedAudio> {
        use futures_util::StreamExt;
        let config_message = crate::tts::build_config_message(config);
        let ssml_message = crate::tts::build_ssml_message(text, config);
        self.0.send(config_message).await?;
        self.0.send(ssml_message).await?;

        let mut audio_bytes = Vec::new();
        let mut audio_metadata = Vec::new();
        let mut turn_start = false;
        let mut response = false;
        let mut turn_end = false;
        loop {
            if turn_end {
                break;
            }

            if let Some(message) = self.0.next().await {
                let message = message?;
                let payload = crate::tts::Payload::process(
                    message,
                    &mut turn_start,
                    &mut response,
                    &mut turn_end,
                )?;
                if let Some(payload) = payload {
                    match payload {
                        crate::tts::Payload::AudioBytes(payload) => {
                            audio_bytes.push(payload);
                        }
                        crate::tts::Payload::AudioMetadata(metadata) => {
                            audio_metadata.extend(metadata);
                        }
                    }
                }
            }
        }

        let audio_bytes = audio_bytes
            .iter()
            .flat_map(|(bytes, index)| &bytes[*index..])
            .copied()
            .collect();

        Ok(SynthesizedAudio {
            audio_format: config.audio_format.clone(),
            audio_bytes,
            audio_metadata,
        })
    }
}

#[cfg(feature = "blocking")]
mod blocking;
#[cfg(feature = "blocking")]
#[cfg_attr(docsrs, doc(cfg(feature = "blocking")))]
pub use blocking::*;

#[cfg(feature = "smol-runtime")]
#[cfg_attr(docsrs, doc(cfg(feature = "smol-runtime")))]
pub mod smol_runtime;

#[cfg(feature = "tokio-runtime")]
#[cfg_attr(docsrs, doc(cfg(feature = "tokio-runtime")))]
pub mod tokio_runtime;