• Unity 工具 之 Azure 微软语音合成普通方式和流式获取音频数据的简单整理

    Unity 工具 之 Azure 微软语音合成普通方式和流式获取音频数据的简单整理

    目录

    Unity 工具 之 Azure 微软语音合成普通方式和流式获取音频数据的简单整理

    一、简单介绍

    二、实现原理

    三、注意实现

    四、实现步骤

     六、关键脚本

    附加：

    声音设置相关

    一、简单介绍

    Unity 工具类，自己整理的一些游戏开发可能用到的模块，单独独立使用，方便游戏开发。

    本节介绍，这里在使用微软的Azure 进行语音合成的两个方法的做简单整理，这里简单说明，如果你有更好的方法，欢迎留言交流。

    官网注册：

    面向学生的 Azure - 免费帐户额度 | Microsoft Azure

    官网技术文档网址：

    技术文档 | Microsoft Learn

    官网的TTS：

    文本转语音快速入门 - 语音服务 - Azure Cognitive Services | Microsoft Learn

    Azure Unity SDK  包官网：

    安装语音 SDK - Azure Cognitive Services | Microsoft Learn

    SDK具体链接：

    https://aka.ms/csspeech/unitypackage

    二、实现原理

    1、官网申请得到语音合成对应的 SPEECH_KEY 和 SPEECH_REGION

    2、然后对应设置 语言 和需要的声音 配置

    3、使用 普通方式 和 流式获取得到音频数据，在声源中播放即可

    三、注意实现

    1、在合成语音文本较长的情况下，流式获取的速度明显会优于普通的方式

    2、目前流式获取的方式，我是暂时没有好的方式管理网络错误和音频播放结束的事件

    （如果有兄弟集美们知道，还请留言赐教哈）

    四、实现步骤

    1、下载好SDK 导入

    2、简单的搭建场景

    3、写测试脚本，和普通获取和流式获取方式

    4、把测试脚本添加到场景中，并赋值

     5、运行，输入文字，点击对应按钮即可

     六、关键脚本

    1、Test

    1.  
    2. using UnityEngine;
    3. using UnityEngine.UI;
    4.  
    5. public class Test : MonoBehaviour
    6. {
    7.     public InputField m_InputField;
    8.     public Button m_StreamButton;
    9.     public Button m_NormalButton;
    10.     public AudioSource m_AudioSource;
    11.  
    12.     // Start is called before the first frame update
    13.     void Start()
    14.     {
    15.  
    16.         m_StreamButton.onClick.AddListener(() => {
    17.             AzureTTSStream.Instance.StartTTS(m_InputField.text, m_AudioSource);
    18.         });
    19.         m_NormalButton.onClick.AddListener(() => {
    20.             AzureTTSNormal.Instance.StartTTS(m_InputField.text, m_AudioSource);
    21.         });
    22.     }
    23.  
    24. }

    2、AzureTTSNormal

    1. using Microsoft.CognitiveServices.Speech;
    2. using System;
    3. using System.Collections;
    4. using UnityEngine;
    5.  
    6. public class AzureTTSNormal : MonoSingleton<AzureTTSNormal>
    7. {
    8.     private AudioSource m_AudioSource;
    9.  
    10.     private string m_SubscriptionKey = "Your";
    11.     private string m_Region = "Your";
    12.     private string m_SpeechSynthesisLanguage = "zh-CN";
    13.     private string m_SpeechSynthesisVoiceName = "zh-CN-XiaochenNeural";
    14.     private Coroutine m_TTSCoroutine;
    15.  
    16.     /// 
    17.     /// 你的授权
    18.     /// 
    19.     /// 子脚本的Key
    20.     /// 地区
    21.     public void SetAzureAuthorization(string subscriptionKey, string region)
    22.     {
    23.         m_SubscriptionKey = subscriptionKey;
    24.         m_Region = region;
    25.     }
    26.  
    27.     /// 
    28.     /// 设置语音和声音
    29.     /// 
    30.     /// 语言
    31.     /// 声音
    32.     public void SetLanguageVoiceName(SpeechSynthesisLanguage language, SpeechSynthesisVoiceName voiceName)
    33.     {
    34.         m_SpeechSynthesisLanguage = language.ToString().Replace('_', '-');
    35.         m_SpeechSynthesisVoiceName = voiceName.ToString().Replace('_', '-');
    36.     }
    37.  
    38.     /// 
    39.     /// 设置音源
    40.     /// 
    41.     /// 
    42.     public void SetAudioSource(AudioSource audioSource)
    43.     {
    44.         m_AudioSource = audioSource;
    45.     }
    46.  
    47.     /// 
    48.     /// 开始TTS
    49.     /// 
    50.     /// 
    51.     /// 
    52.     public void StartTTS(string spkMsg, Action<string> errorAction = null)
    53.     {
    54.         StopTTS();
    55.         m_TTSCoroutine = StartCoroutine(SynthesizeAudioCoroutine(spkMsg, errorAction));
    56.     }
    57.  
    58.     /// 
    59.     /// 开始TTS
    60.     /// 
    61.     /// 
    62.     /// 
    63.     /// 
    64.     public void StartTTS(string spkMsg, AudioSource audioSource, Action<string> errorAction = null)
    65.     {
    66.         SetAudioSource(audioSource);
    67.         StartTTS(spkMsg, errorAction);
    68.     }
    69.  
    70.     /// 
    71.     /// 暂停TTS
    72.     /// 
    73.     public void StopTTS()
    74.     {
    75.         if (m_TTSCoroutine != null)
    76.         {
    77.             StopCoroutine(m_TTSCoroutine);
    78.             m_TTSCoroutine = null;
    79.         }
    80.         if (m_AudioSource != null)
    81.         {
    82.             m_AudioSource.Stop();
    83.             m_AudioSource.clip = null;
    84.         }
    85.     }
    86.  
    87.     public IEnumerator SynthesizeAudioCoroutine(string spkMsg, Action<string> errorAction)
    88.     {
    89.         yield return null;
    90.         var config = SpeechConfig.FromSubscription(m_SubscriptionKey, m_Region);
    91.         config.SpeechSynthesisLanguage = m_SpeechSynthesisLanguage;
    92.         config.SpeechSynthesisVoiceName = m_SpeechSynthesisVoiceName;
    93.         // Creates a speech synthesizer.
    94.         // Make sure to dispose the synthesizer after use!
    95.         using (var synthsizer = new SpeechSynthesizer(config, null))
    96.         {
    97.  
    98.             // Starts speech synthesis, and returns after a single utterance is synthesized.
    99.             var result = synthsizer.SpeakTextAsync(spkMsg).Result;
    100.             //print("after   " + DateTime.Now);
    101.  
    102.             // Checks result.
    103.             string newMessage = string.Empty;
    104.             if (result.Reason == ResultReason.SynthesizingAudioCompleted)
    105.             {
    106.                 // Since native playback is not yet supported on Unity yet (currently only supported on Windows/Linux Desktop),
    107.                 // use the Unity API to play audio here as a short term solution.
    108.                 // Native playback support will be added in the future release.
    109.                 var sampleCount = result.AudioData.Length / 2;
    110.                 var audioData = new float[sampleCount];
    111.                 for (var i = 0; i < sampleCount; ++i)
    112.                 {
    113.                     audioData[i] = (short)(result.AudioData[i * 2 + 1] << 8 | result.AudioData[i * 2]) / 32768.0F;
    114.  
    115.                 }
    116.                 // The default output audio format is 16K 16bit mono
    117.                 var audioClip = AudioClip.Create("SynthesizedAudio", sampleCount, 1, 16000, false);
    118.                 audioClip.SetData(audioData, 0);
    119.                 m_AudioSource.clip = audioClip;
    120.                 Debug.Log(" audioClip.length " + audioClip.length);
    121.                 m_AudioSource.Play();
    122.  
    123.  
    124.             }
    125.  
    126.             else if (result.Reason == ResultReason.Canceled)
    127.             {
    128.                 var cancellation = SpeechSynthesisCancellationDetails.FromResult(result);
    129.                 newMessage = $"CANCELED:\nReason=[{cancellation.Reason}]\nErrorDetails=[{cancellation.ErrorDetails}]\nDid you update the subscription info?";
    130.                 Debug.Log(" newMessage "+ newMessage);
    131.                 if (errorAction!=null) { errorAction.Invoke(newMessage); }
    132.  
    133.             }
    134.  
    135.  
    136.         }
    137.     }
    138. }

    3、AzureTTSStream

    1. using UnityEngine;
    2. using Microsoft.CognitiveServices.Speech;
    3. using System.IO;
    4. using System;
    5. using System.Collections;
    6.  
    7. public class AzureTTSStream : MonoSingleton<AzureTTSStream>
    8. {
    9.     private AudioSource m_AudioSource;
    10.  
    11.     private string m_SubscriptionKey = "Your";
    12.  
    13.     private string m_Region = "Your";
    14.  
    15.     private string m_SpeechSynthesisLanguage = "zh-CN";
    16.  
    17.     private string m_SpeechSynthesisVoiceName = "zh-CN-XiaochenNeural";
    18.  
    19.     public const int m_SampleRate = 16000;
    20.  
    21.     public const int m_BufferSize = m_SampleRate * 60; //最大支持60s音频，但是也可以调大，流式的无所谓
    22.  
    23.     public const int m_UpdateSize = m_SampleRate / 10; //采样容量，越大越卡
    24.  
    25.     private Coroutine m_TTSCoroutine;
    26.     private int m_DataIndex = 0;
    27.  
    28.     private AudioDataStream m_AudioDataStream;
    29.  
    30.     private void OnEnable()
    31.     {
    32.         StopTTS();
    33.     }
    34.  
    35.     private void OnDisable()
    36.     {
    37.         StopTTS();
    38.     }
    39.  
    40.     /// 
    41.     /// 你的授权
    42.     /// 
    43.     /// 子脚本的Key
    44.     /// 地区
    45.     public void SetAzureAuthorization(string subscriptionKey, string region)
    46.     {
    47.         m_SubscriptionKey = subscriptionKey;
    48.         m_Region = region;
    49.     }
    50.  
    51.     /// 
    52.     /// 设置语音和声音
    53.     /// 
    54.     /// 语言
    55.     /// 声音
    56.     public void SetLanguageVoiceName(SpeechSynthesisLanguage language, SpeechSynthesisVoiceName voiceName)
    57.     {
    58.         m_SpeechSynthesisLanguage = language.ToString().Replace('_', '-');
    59.         m_SpeechSynthesisVoiceName = voiceName.ToString().Replace('_', '-');
    60.     }
    61.  
    62.     /// 
    63.     /// 设置音源
    64.     /// 
    65.     /// 
    66.     public void SetAudioSource(AudioSource audioSource)
    67.     {
    68.         m_AudioSource = audioSource;
    69.     }
    70.  
    71.     /// 
    72.     /// 开始TTS
    73.     /// 
    74.     /// 
    75.     /// 
    76.     public void StartTTS(string spkMsg, Action<string> errorAction = null)
    77.     {
    78.         StopTTS();
    79.         m_TTSCoroutine = StartCoroutine(SynthesizeAudioCoroutine(spkMsg, errorAction));
    80.     }
    81.  
    82.     /// 
    83.     /// 开始TTS
    84.     /// 
    85.     /// 
    86.     /// 
    87.     /// 
    88.     public void StartTTS(string spkMsg, AudioSource audioSource, Action<string> errorAction = null)
    89.     {
    90.         SetAudioSource(audioSource);
    91.         StartTTS(spkMsg, errorAction);
    92.     }
    93.  
    94.     /// 
    95.     /// 暂停TTS
    96.     /// 
    97.     public void StopTTS()
    98.     {
    99.         // 释放流
    100.         if (m_AudioDataStream != null)
    101.         {
    102.             m_AudioDataStream.Dispose();
    103.             m_AudioDataStream = null;
    104.         }
    105.  
    106.         if (m_TTSCoroutine != null)
    107.         {
    108.             StopCoroutine(m_TTSCoroutine);
    109.             m_TTSCoroutine = null;
    110.  
    111.         }
    112.         if (m_AudioSource != null)
    113.         {
    114.             m_AudioSource.Stop();
    115.             m_AudioSource.clip = null;
    116.             m_DataIndex = 0;
    117.         }
    118.     }
    119.  
    120.     /// 
    121.     /// 发起TTS
    122.     /// 
    123.     /// TTS的文本
    124.     /// 错误事件（目前没有好的判断方法）
    125.     /// 
    126.     private IEnumerator SynthesizeAudioCoroutine(string speakMsg, Action<string> errorAction)
    127.     {
    128.         var config = SpeechConfig.FromSubscription(m_SubscriptionKey, m_Region);
    129.         config.SpeechSynthesisLanguage = m_SpeechSynthesisLanguage;
    130.         config.SpeechSynthesisVoiceName = m_SpeechSynthesisVoiceName;
    131.         var audioClip = AudioClip.Create("SynthesizedAudio", m_BufferSize, 1, m_SampleRate, false);
    132.         m_AudioSource.clip = audioClip;
    133.         using (var synthesizer = new SpeechSynthesizer(config, null))
    134.         {
    135.  
    136.             var result = synthesizer.StartSpeakingTextAsync(speakMsg);
    137.             yield return new WaitUntil(() => result.IsCompleted);
    138.             m_AudioSource.Play();
    139.             using (m_AudioDataStream = AudioDataStream.FromResult(result.Result))
    140.             {
    141.                 MemoryStream memStream = new MemoryStream();
    142.                 byte[] buffer = new byte[m_UpdateSize * 2];
    143.                 uint bytesRead;
    144.                 do
    145.                 {
    146.                     bytesRead = m_AudioDataStream.ReadData(buffer);
    147.                     memStream.Write(buffer, 0, (int)bytesRead);
    148.                     if (memStream.Length >= m_UpdateSize * 2)
    149.                     {
    150.                         var tempData = memStream.ToArray();
    151.                         var audioData = new float[m_UpdateSize];
    152.                         for (int i = 0; i < m_UpdateSize; ++i)
    153.                         {
    154.                             audioData[i] = (short)(tempData[i * 2 + 1] << 8 | tempData[i * 2]) / 32768.0F;
    155.                         }
    156.  
    157.                         audioClip.SetData(audioData, m_DataIndex);
    158.                         m_DataIndex = (m_DataIndex + m_UpdateSize) % m_BufferSize;
    159.  
    160.                         memStream = new MemoryStream();
    161.                         yield return null;
    162.                     }
    163.                 } while (bytesRead > 0);
    164.  
    165.             }
    166.         }
    167.  
    168.         if (m_DataIndex == 0)
    169.         {
    170.             if (errorAction != null)
    171.             {
    172.                 errorAction.Invoke(" AudioData error");
    173.             }
    174.         }
    175.     }
    176. }
    177.  
    178. /// 
    179. /// 添加更多的其他语言
    180. /// 形式类似为 Zh_CN 对应 "zh-CN";
    181. /// 
    182. public enum SpeechSynthesisLanguage
    183. {
    184.     Zh_CN,
    185. }
    186.  
    187. /// 
    188. /// 添加更多的其他声音
    189. /// 形式类似为 Zh_CN_XiaochenNeural 对应 "zh-CN-XiaochenNeural";
    190. /// 
    191. public enum SpeechSynthesisVoiceName
    192. {
    193.     Zh_CN_XiaochenNeural,
    194. }

    4、MonoSingleton

    1. using UnityEngine;
    2. public class MonoSingleton<T> : MonoBehaviour where T : MonoBehaviour
    3. {
    4.     private static T instance;
    5.     public static T Instance
    6.     {
    7.         get
    8.         {
    9.             if (instance == null)
    10.             {
    11.                 // 查找存在的实例
    12.                 instance = (T)FindObjectOfType(typeof(T));
    13.  
    14.                 // 如果不存在实例，则创建
    15.                 if (instance == null)
    16.                 {
    17.                     // 需要创建一个游戏对象，再把这个单例组件挂载到游戏对象上
    18.                     var singletonObject = new GameObject();
    19.                     instance = singletonObject.AddComponent();
    20.                     singletonObject.name = typeof(T).ToString() + " (Singleton)";
    21.  
    22.                     // 让实例不在切换场景时销毁
    23.                     DontDestroyOnLoad(singletonObject);
    24.                 }
    25.             }
    26.  
    27.             return instance;
    28.         }
    29.     }
    30. }

    优化流式读取数据的卡顿

    1. using FfalconXR;
    2. using Microsoft.CognitiveServices.Speech;
    3. using System;
    4. using System.Collections;
    5. using System.IO;
    6. using System.Threading.Tasks;
    7. using System.Threading;
    8. using UnityEngine;
    9.  
    10. public class AzureTTSStream : MonoSingleton<AzureTTSStream>
    11. {
    12.     const string TAG = "【Unity AzureTTS】";
    13.     bool m_IsShowLog=true;
    14.  
    15.     private AudioSource m_AudioSource;
    16.  
    17.     private string m_SubscriptionKey = "YOUR_KEY";
    18.  
    19.     private string m_Region = "eastasia";
    20.  
    21.     private string m_SpeechSynthesisLanguage = "zh-CN"; //"zh-cn-sichuan";
    22.  
    23.     private string m_SpeechSynthesisVoiceName = "zh-CN-XiaochenNeural"; // "zh-cn-sichuan-YunxiNeural"; //"zh-cn-shaanxi-XiaoniNeural";
    24.  
    25.     public const int m_SampleRate = 16000;
    26.  
    27.     public const int m_BufferSize = m_SampleRate * 60; //最大支持60s音频，但是也可以调大，流式的无所谓
    28.  
    29.     public const int m_UpdateSize = m_SampleRate / 10; //采样容量，越大越卡
    30.  
    31.     private Coroutine m_TTSCoroutine;
    32.     private int m_DataIndex = 0;
    33.     private SpeechConfig m_SpeechConfig;
    34.     private AudioDataStream m_AudioDataStream;
    35.     private Task m_Task;
    36.     private CancellationTokenSource m_CancellationTokenSource;
    37.     private SpeechSynthesizer m_SpeechSynthesizer;
    38.     private bool m_IsSpeechSynthesizerInitialized;
    39.     protected override void Awake()
    40.     {
    41.         base.Awake();
    42.         m_SpeechConfig = SpeechConfig.FromSubscription(m_SubscriptionKey, m_Region);
    43.         m_SpeechConfig.SpeechSynthesisLanguage = m_SpeechSynthesisLanguage;
    44.         m_SpeechConfig.SpeechSynthesisVoiceName = m_SpeechSynthesisVoiceName;
    45.     }
    46.     private void Start()
    47.     {
    48.         InitializeSpeechSynthesizer();
    49.     }
    50.  
    51.     private void OnEnable()
    52.     {
    53.         StopTTS();
    54.     }
    55.  
    56.     private void OnDisable()
    57.     {
    58.         StopTTS();
    59.     }
    60.  
    61.     protected override void OnDestroy()
    62.     {
    63.         StopTTS();
    64.         DisposeSpeechSynthesizer();
    65.     }
    66.  
    67.     public void SetAzureAuthorization(string subscriptionKey, string region) { 
    68.         m_SubscriptionKey= subscriptionKey;
    69.         m_Region= region;
    70.     }
    71.  
    72.     public void SetLanguageVoiceName(SpeechSynthesisLanguage language, SpeechSynthesisVoiceName voiceName)
    73.     {
    74.         m_SpeechSynthesisLanguage = language.ToString().Replace('_','-');
    75.         m_SpeechSynthesisVoiceName = voiceName.ToString().Replace('_', '-');
    76.         Debug.Log(" m_SpeechSynthesisLanguage " + m_SpeechSynthesisLanguage);
    77.         Debug.Log(" m_SpeechSynthesisVoiceName " + m_SpeechSynthesisVoiceName);
    78.     }
    79.  
    80.     public void SetAudioSource(AudioSource audioSource)
    81.     {
    82.         m_AudioSource= audioSource;
    83.     }
    84.  
    85.     public async void StartTTS(string spkMsg, Action startAction, Action<string> errorAction=null)
    86.     {
    87.         StopTTS();
    88.         //m_TTSCoroutine = StartCoroutine(SynthesizeAudioCoroutine(spkMsg, startAction, errorAction));
    89.         await SynthesizeAudioAsync(spkMsg, startAction, errorAction);
    90.     }
    91.  
    92.     public void StartTTS(string spkMsg, AudioSource audioSource, Action startAction, Action<string> errorAction=null)
    93.     {
    94.         SetAudioSource(audioSource);
    95.         StartTTS(spkMsg, startAction, errorAction);
    96.     }
    97.  
    98.     public void StopTTS()
    99.     {
    100.         // 释放流
    101.         if (m_AudioDataStream != null)
    102.         {
    103.             m_AudioDataStream.Dispose();
    104.             m_AudioDataStream = null;
    105.         }
    106.  
    107.         if (m_CancellationTokenSource != null)
    108.         {
    109.             m_CancellationTokenSource.Cancel();
    110.         }
    111.  
    112.         if (m_TTSCoroutine != null)
    113.         {
    114.             StopCoroutine(m_TTSCoroutine);
    115.             m_TTSCoroutine = null;
    116.  
    117.         }
    118.         if (m_AudioSource!=null)
    119.         {
    120.             m_AudioSource.Stop();
    121.             m_AudioSource.clip = null;
    122.             m_DataIndex = 0;
    123.         }
    124.     }
    125.  
    126.     /// 
    127.     /// 发起TTS
    128.     /// 
    129.     /// TTS的文本
    130.     /// 错误事件（目前没有好的判断方法）
    131.     /// 
    132.     private IEnumerator SynthesizeAudioCoroutine(string speakMsg, Action startAction,Action<string> errorAction)
    133.     {
    134.         var audioClip = AudioClip.Create("SynthesizedAudio", m_BufferSize, 1, m_SampleRate, false);
    135.         m_AudioSource.clip = audioClip;
    136.         startAction?.Invoke();
    137.         using (var synthesizer = new SpeechSynthesizer(m_SpeechConfig, null))
    138.         {
    139.             var result = synthesizer.StartSpeakingTextAsync(speakMsg);
    140.             yield return new WaitUntil(() => result.IsCompleted);
    141.             m_AudioSource.Play();
    142.             using (m_AudioDataStream = AudioDataStream.FromResult(result.Result))
    143.             {
    144.                 MemoryStream memStream = new MemoryStream();
    145.                 byte[] buffer = new byte[m_UpdateSize * 2];
    146.                 uint bytesRead;
    147.                 do
    148.                 {
    149.                     bytesRead = m_AudioDataStream.ReadData(buffer);
    150.                     memStream.Write(buffer, 0, (int)bytesRead);
    151.                     if (memStream.Length >= m_UpdateSize * 2)
    152.                     {
    153.                         var tempData = memStream.ToArray();
    154.                         var audioData = new float[m_UpdateSize];
    155.                         for (int i = 0; i < m_UpdateSize; ++i)
    156.                         {
    157.                             audioData[i] = (short)(tempData[i * 2 + 1] << 8 | tempData[i * 2]) / 32768.0F;
    158.                         }
    159.  
    160.                         audioClip.SetData(audioData, m_DataIndex);
    161.                         m_DataIndex = (m_DataIndex + m_UpdateSize) % m_BufferSize;
    162.  
    163.                         memStream = new MemoryStream();
    164.                         yield return null;
    165.                     }
    166.                 } while (bytesRead > 0);
    167.  
    168.             }
    169.         }
    170.  
    171.         if (m_DataIndex==0) {
    172.             if (errorAction!=null)
    173.             {
    174.                 errorAction.Invoke(" AudioData error");
    175.             }
    176.         }
    177.     }
    178.  
    179.     /// 
    180.     /// async 方式
    181.     /// 
    182.     /// 
    183.     /// 
    184.     /// 
    185.     private async Task SynthesizeAudioAsync(string speakMsg, Action startAction, Action<string> errorAction) {
    186.         StopTTS();
    187.         m_CancellationTokenSource = new CancellationTokenSource();
    188.  
    189.         if (!m_IsSpeechSynthesizerInitialized)
    190.         {
    191.             // 如果 SpeechSynthesizer 尚未初始化，则在需要时进行初始化
    192.             InitializeSpeechSynthesizer();
    193.         }
    194.         try
    195.         {
    196.             using (var result = await m_SpeechSynthesizer.StartSpeakingTextAsync(speakMsg))
    197.             {
    198.                 using (m_AudioDataStream = AudioDataStream.FromResult(result))
    199.                 {
    200.                     var audioClip = AudioClip.Create("SynthesizedAudio", m_BufferSize, 1, m_SampleRate, false);
    201.                     m_AudioSource.clip = audioClip;
    202.  
    203.                     startAction?.Invoke();
    204.  
    205.                     MemoryStream memStream = new MemoryStream();
    206.                     byte[] buffer = new byte[m_UpdateSize * 2];
    207.                     uint bytesRead = 0;
    208.  
    209.                     do
    210.                     {
    211.                         if (m_CancellationTokenSource.IsCancellationRequested)
    212.                         {
    213.                             break; // 取消操作，退出循环
    214.                         }
    215.  
    216.                         bytesRead = await Task.Run(() => m_AudioDataStream.ReadData(buffer));
    217.                         if (m_IsShowLog) Debug.Log(TAG + $"{bytesRead} bytes received.");
    218.                         await memStream.WriteAsync(buffer, 0, (int)bytesRead);
    219.                         if (memStream.Length >= m_UpdateSize * 2)
    220.                         {
    221.                             var tempData = memStream.ToArray();
    222.                             var audioData = new float[m_UpdateSize];
    223.                             for (int i = 0; i < m_UpdateSize; ++i)
    224.                             {
    225.                                 audioData[i] = (short)(tempData[i * 2 + 1] << 8 | tempData[i * 2]) / 32768.0F;
    226.                             }
    227.  
    228.                             audioClip.SetData(audioData, m_DataIndex);
    229.                             m_DataIndex = (m_DataIndex + m_UpdateSize) % m_BufferSize;
    230.  
    231.                             if (m_AudioSource.isPlaying == false)
    232.                             {
    233.                                 m_AudioSource.Play();
    234.                             }
    235.  
    236.                             memStream = new MemoryStream();
    237.                         }
    238.  
    239.                         await Task.Yield(); // 让出一帧的时间给主线程
    240.  
    241.  
    242.                     } while (bytesRead > 0);
    243.                 }
    244.             }
    245.         }
    246.         catch (Exception e)
    247.         {
    248.             if (m_IsShowLog) Debug.Log(TAG + e.Message);
    249.         }
    250.         
    251.     }
    252.  
    253.     private void InitializeSpeechSynthesizer()
    254.     {
    255.         var config = SpeechConfig.FromSubscription(m_SubscriptionKey, m_Region);
    256.         config.SpeechSynthesisLanguage = m_SpeechSynthesisLanguage;
    257.         config.SpeechSynthesisVoiceName = m_SpeechSynthesisVoiceName;
    258.  
    259.         m_SpeechSynthesizer = new SpeechSynthesizer(config, null);
    260.         m_IsSpeechSynthesizerInitialized = true;
    261.     }
    262.  
    263.     private void DisposeSpeechSynthesizer()
    264.     {
    265.         // 停止语音合成并释放资源
    266.         if (m_SpeechSynthesizer != null)
    267.         {
    268.             m_SpeechSynthesizer.StopSpeakingAsync();
    269.             m_SpeechSynthesizer.Dispose();
    270.             m_SpeechSynthesizer = null;
    271.             m_IsSpeechSynthesizerInitialized = false;
    272.         }
    273.     }
    274. }
    275.  
    276. public enum SpeechSynthesisLanguage {
    277.     Zh_CN,
    278.     zh_cn_sichuan
    279. }
    280.  
    281. public enum SpeechSynthesisVoiceName {
    282.     Zh_CN_XiaochenNeural,
    283. }

    附加：

    声音设置相关

    语言支持 - 语音服务 - Azure Cognitive Services | Azure Docs

    中国部分声音选择设置：

    wuu-CN中文（吴语，简体）wuu-CN-XiaotongNeural1，2（女）
    wuu-CN-YunzheNeural1，2（男）
    yue-CN中文（粤语，简体）yue-CN-XiaoMinNeural1，2（女）
    yue-CN-YunSongNeural1，2（男）
    zh-cn中文（普通话，简体）zh-cn-XiaochenNeural（女）
    zh-cn-XiaohanNeural（女）
    zh-cn-XiaomengNeural（女）
    zh-cn-XiaomoNeural（女）
    zh-cn-XiaoqiuNeural（女）
    zh-cn-XiaoruiNeural（女）
    zh-cn-XiaoshuangNeural（女性、儿童）
    zh-cn-XiaoxiaoNeural（女）
    zh-cn-XiaoxuanNeural（女）
    zh-cn-XiaoyanNeural（女）
    zh-cn-XiaoyiNeural（女）
    zh-cn-XiaoyouNeural（女性、儿童）
    zh-cn-XiaozhenNeural（女）
    zh-cn-YunfengNeural（男）
    zh-cn-YunhaoNeural（男）
    zh-cn-YunjianNeural（男）
    zh-cn-YunxiaNeural（男）
    zh-cn-YunxiNeural（男）
    zh-cn-YunyangNeural（男）
    zh-cn-YunyeNeural（男）
    zh-cn-YunzeNeural（男）
    zh-cn-henan中文（中原官话河南，简体）zh-cn-henan-YundengNeural2（男）
    zh-cn-liaoning中文（东北官话，简体）zh-cn-liaoning-XiaobeiNeural1，2（女）
    zh-cn-shaanxi中文（中原官话陕西，简体）zh-cn-shaanxi-XiaoniNeural1，2（女）
    zh-cn-shandong中文（冀鲁官话，简体）zh-cn-shandong-YunxiangNeural2（男）
    zh-cn-sichuan中文（西南普通话，简体）zh-cn-sichuan-YunxiNeural1，2（男）
    zh-HK中文(粤语，繁体)zh-HK-HiuGaaiNeural（女）
    zh-HK-HiuMaanNeural（女）
    zh-HK-WanLungNeural1（男）
    zh-TW中文（台湾普通话，繁体）zh-TW-HsiaoChenNeural（女）
    zh-TW-HsiaoYuNeural（女）
    zh-TW-YunJheNeural（男）
    zu-ZA祖鲁语（南非）zu-ZA-ThandoNeural2（女）
    zu-ZA-ThembaNeural2（男）
  • 相关阅读:
    若依框架下首次写接口
    汉语言文学类毕业论文，有什么好写的选题？
    EasyExcel的使用
    基于R和gephi做宏基因组与代谢组等多组学联合network相关性网络图
    企业完善质量、环境、健康安全三体系认证的作用及其意义！
    鸿蒙Harmony应用开发—ArkTS声明式开发（通用属性：形状裁剪）
    Mac，Windows11，Windows10局域网互传共享文件
    德博能源、西门子能源、霍尼韦尔等出席2023中国可持续生物燃料峰会
    YOLOv7训练自己的数据集
    高阶python | 装饰器
  • 原文地址：https://blog.csdn.net/u014361280/article/details/130902485