msedge tts

คำอธิบาย

ไลบรารีนี้เป็น wrapper ของ MSEDGE อ่านฟังก์ชั่นออกเสียง API คุณสามารถใช้เพื่อสังเคราะห์ข้อความเพื่อพูดด้วยเสียงที่ MS มีให้มากมาย

วิธีใช้

1. คุณต้องได้รับ 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 ด้วยตัวเอง ตรวจสอบให้แน่ใจว่าคุณรู้ ชื่อเสียง และ รูปแบบเสียง ที่เหมาะสม
2. สร้าง Client TTS หรือ Stream ทั้งคู่มีเวอร์ชันซิงค์และ async ตัวอย่างด้านล่างขั้นตอนที่ 3
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 ;
           }
       }
   }

   ไคลเอนต์ async

   การเรียกใช้ฟังก์ชั่น 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 Return 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" ) ;
                   }
               }
           }
       }
   }

   สตรีม async

   ฟังก์ชั่นผู้ส่ง Async send ไปยังการสังเคราะห์ข้อความเป็นคำพูด ฟังก์ชั่นเครื่องอ่านเครื่องอ่าน Async 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" ) ;
                       }
                   }
               }
           }
       } ) ;
   }

ดูตัวอย่างทั้งหมด