msedge ttsダウンロードmsedge ttsソースコードのダウンロード

msedge tts

AI ソースコード

1.0.0

ダウンロード

説明

このライブラリは、Msedgeの読み取り声のAPIのラッパーです。これを使用して、MSが提供する多くの声でテキストを統合することができます。

使い方

テキストの音声をスピーチに設定するには、 SpeechConfig取得する必要があります。
VoiceをSpeechConfigに簡単に変換できます。 get_voices_list関数を使用して、利用可能なすべての声を取得します。
Voice and SpeechConfig serde::Serializeと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、 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 ;
        }
    }
}

Asyncクライアント

クライアント関数をコールして、テキストをスピーチにsynthesizeします。この関数SynthesizedAudioタイプ合成audio、 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 。
Return Option<SynthesizedResponse> read 、応答はAudioBytesまたはAudioMetadataである場合があります。これは、 MSEDEDがALAUD APIを読み取り、複数のデータセグメントとメタデータ、およびその他の情報を順番に返すためです。
注意： send複数のreadに対応します。次のsendコールは、読み取るデータがないまでブロックされます。 sendを呼び出す前にreadがブロックされます。

 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" ) ;
                }
            }
        }
    }
}

非同期ストリーム

Sender async関数を呼び出して、テキストを合成しsend 。データを取得するには、読者async関数read 。上記のように、return Option<SynthesizedResponse> read 。上記のようにブロック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" ) ;
                    }
                }
            }
        }
    } ) ;
}