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_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 . 데이터를 얻으려면 Reader Stream 기능을 read 하십시오.
리턴 옵션을 read Option<SynthesizedResponse> , 응답은 AudioBytes 또는 AudioMetadata 또는 없을 수 있습니다. 이는 MSEDGE가 API를 API를 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" ) ;
                }
            }
        }
    }
}

비동기 스트림

발신자 비동기 기능을 호출하여 음성으로 텍스트를 합성 send . 데이터를 read 려면 Reader Async 함수를 호출하십시오. 반환 옵션을 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" ) ;
                    }
                }
            }
        }
    } ) ;
}