msedge tts

Описание

Эта библиотека является оберткой MSEDGE Read API функции. Вы можете использовать его для синтеза текста к речи со многими голосами, предоставленными MS.

Как использовать

1. Вам нужно получить SpeechConfig для настройки голоса текста на речь.
   Вы можете просто преобразовать Voice в SpeechConfig просто. Используйте функцию get_voices_list , чтобы получить все доступные голоса.
   Voice и 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 . Они оба имеют синхронизацию и асинхронную версию. Пример ниже Шаг 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 ;
           }
       }
   }

   Асинхровый клиент

   Вызовите клиентскую функцию 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 Read 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 Function send для синтеза текста в речь. Вызовой чтения Async Function 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" ) ;
                       }
                   }
               }
           }
       } ) ;
   }

Смотрите все примеры.