msedge tts下載msedge tts源代碼下載

msedge tts

Ai源碼

1.0.0

下載

描述

該庫是MSEDGE讀取大聲函數API的包裝器。您可以使用它來合成文本以使用許多聲音MS進行語音。

如何使用

您需要獲取SpeechConfig才能將文本的語音配置為語音。
您可以簡單地將Voice轉換為SpeechConfig 。使用get_voices_list函數獲取所有可用的聲音。
Voice和言語SpeechConfig實現了serde::Serialize and serde::Deserialize 。
例如：
```
 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 ] ) ;
}
```
您還可以自己創建SpeechConfig 。確保您知道正確的語音名稱和音頻格式。
創建TTS Client或Stream 。他們倆都有同步版和異步版本。下面的示例步驟3。

將文本綜合為語音。

同步客戶端

調用客戶端函數synthesize以綜合文本為語音。此函數返回類型SynthesizedAudio ，您可以獲取audio_bytes和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 ;
        }
    }
}

異步客戶端

調用客戶端函數synthesize以綜合文本為語音。此函數返回類型SynthesizedAudio ，您可以獲取audio_bytes和audio_metadata 。

 use msedge_tts :: { tts :: client :: connect_async , tts :: SpeechConfig , voice :: get_voices_list_async } ;

fn main ( ) {
    smol :: block_on ( async {
        let voices = get_voices_list_async ( ) . await . unwrap ( ) ;
        for voice in & voices {
            if voice . name . contains ( "YunyangNeural" ) {
                let config = SpeechConfig :: from ( voice ) ;
                let mut tts = connect_async ( ) . await . unwrap ( ) ;
                let audio = tts
                    . synthesize ( "Hello, World! 你好，世界！" , & config )
                    . await
                    . unwrap ( ) ;
                break ;
            }
        }
    } ) ;
}

同步流

調用發件人流函數send到綜合文本到語音。調用讀取器流函數read以獲取數據。
read返回Option<SynthesizedResponse> ，響應可以是AudioBytes ，也可以是AudioMetadata或無。這是因為MSEDGE讀取API依次返回多個數據段和元數據以及其他信息。
注意：一個send對應於多個read 。下一個send呼叫將阻止，直到沒有數據可讀。 read會在您致電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" ) ;
                }
            }
        }
    }
}

異步流

調用發件人異步函數send到綜合文本到語音。調用讀取器異步函數read以獲取數據。 read返回Option<SynthesizedResponse>如上所述。如上所述send並read塊。

 use msedge_tts :: {
    tts :: {
        stream :: { msedge_tts_split_async , SynthesizedResponse } ,
        SpeechConfig ,
    } ,
    voice :: get_voices_list_async ,
} ;
use std :: {
    sync :: {
        atomic :: { AtomicBool , Ordering } ,
        Arc ,
    } ,
} ;

fn main ( ) {
    smol :: block_on ( async {
        let voices = get_voices_list_async ( ) . await . unwrap ( ) ;
        for voice in & voices {
            if voice . name . contains ( "YunyangNeural" ) {
                let config = SpeechConfig :: from ( voice ) ;
                let ( mut sender , mut reader ) = msedge_tts_split_async ( ) . await . unwrap ( ) ;

                let signal = Arc :: new ( AtomicBool :: new ( false ) ) ;
                let end = signal . clone ( ) ;
                smol :: spawn ( async move {
                    sender
                        . send ( "Hello, World! 你好，世界！" , & config )
                        . await
                        . unwrap ( ) ;
                    println ! ( "synthesizing...1" ) ;
                    sender
                        . send ( "Hello, World! 你好，世界！" , & config )
                        . await
                        . unwrap ( ) ;
                    println ! ( "synthesizing...2" ) ;
                    sender
                        . send ( "Hello, World! 你好，世界！" , & config )
                        . await
                        . unwrap ( ) ;
                    println ! ( "synthesizing...3" ) ;
                    sender
                        . send ( "Hello, World! 你好，世界！" , & config )
                        . await
                        . unwrap ( ) ;
                    println ! ( "synthesizing...4" ) ;
                    end . store ( true , Ordering :: Relaxed ) ;
                } )
                . detach ( ) ;

                loop {
                    if signal . load ( Ordering :: Relaxed ) && !reader . can_read ( ) . await {
                        break ;
                    }
                    let audio = reader . read ( ) . await . unwrap ( ) ;
                    if let Some ( audio ) = audio {
                        match audio {
                            SynthesizedResponse :: AudioBytes ( _ ) => {
                                println ! ( "read bytes" )
                            }
                            SynthesizedResponse :: AudioMetadata ( _ ) => {
                                println ! ( "read metadata" )
                            }
                        }
                    } else {
                        println ! ( "read None" ) ;
                    }
                }
            }
        }
    } ) ;
}