腾讯云流式TTS实战：构建大模型对话的实时语音反馈系统

在构建下一代AI应用时，我们追求的不仅是智能，更是自然的交互体验。想象一下，当你与大语言模型对话时，它不仅能理解你的意图，还能像真人一样“边思考边说话”，将生成的文字逐字转化为流畅的语音，那种沉浸感与即时反馈带来的体验提升是革命性的。这正是流式文本语音合成（TTS）技术的魅力所在——它让AI的“思考过程”变得可听、可感。

对于AI产品经理和全栈开发者而言，将大模型的文本流与语音合成流无缝对接，打造出真正实时、自然的语音交互产品，已成为提升用户体验的关键技术路径。然而，从官方文档到实际可用的生产级实现，中间往往横亘着诸多技术挑战：音频拼接的异响问题、WebSocket连接的稳定性、参数调优的细节把控，以及如何在Unity等游戏引擎中优雅地集成这些能力。

本文将带你深入腾讯云流式TTS的实战腹地，不仅提供一套完整的、可直接部署的代码方案，更会聚焦于那些官方文档未曾详述的“坑”与“技巧”。我们将从协议原理讲起，逐步构建一个支持逐字播报的Unity客户端，并重点解决音频流拼接的核心难题，让你在5分钟内掌握关键实现，避开我踩过的那些雷。

1. 流式TTS的核心价值与技术选型

在传统的语音合成方案中，无论是基础TTS还是实时TTS，都需要等待完整的文本输入后，才能开始合成并返回音频。这种“批处理”模式在面对大语言模型（LLM）的流式输出时，会带来明显的延迟和割裂感。用户需要等待模型“写完”一整段话，才能听到语音，交互的流畅性大打折扣。

腾讯云推出的流式文本语音合成接口，正是为解决这一痛点而生。它基于WebSocket协议，支持客户端以“流”的形式持续发送文本片段，服务端则“边接收、边合成、边返回”对应的音频数据。这与LLM的token-by-token生成模式完美契合，能够实现真正的“逐字播报”。

1.1 三种合成方式的深度对比

为了更清晰地理解流式TTS的定位，我们将其与腾讯云提供的其他两种主要合成方式进行对比：

特性维度	基础语音合成	实时语音合成	流式文本语音合成
请求模式	一次性提交完整文本	一次性提交完整文本	持续流式提交文本片段
返回模式	一次性返回完整音频	流式返回完整音频	流式返回对应片段的音频
延迟体验	高（需等待全文合成）	中（需等待全文合成开始）	极低（首个字合成后即开始返回）
适用场景	短文本播报、音频文件生成	语音助手、实时导航播报	大模型对话、实时字幕生成、交互式语音应用
协议	HTTP/HTTPS	WebSocket	WebSocket
文本长度限制	300字	300字	单次连接累计最多10000字
核心优势	简单、稳定	实时性较好	超低延迟、与文本流完美同步

从表格可以看出，流式TTS在延迟敏感和交互性强的场景中具有不可替代的优势。它本质上解耦了文本输入与音频输出的时序关系，允许两者并行推进。

1.2 技术架构与协议解析

流式TTS的整个交互过程建立在WebSocket长连接之上，这是一个典型的请求-响应-流混合模式。理解其状态机对于后续的故障排查和性能优化至关重要。

整个生命周期可以分为四个明确的阶段：

1. 握手与鉴权阶段：客户端通过携带签名参数的WebSocket URL发起连接。服务端验证签名后，返回code为0的成功消息，建立会话。
2. 就绪（READY）阶段：服务端完成初始化后，会发送一个ready字段为1的文本消息，告知客户端：“我已准备好，可以开始发送合成文本了”。
3. 合成（SYNTHESIS）阶段：这是核心阶段。客户端不断发送ACTION_SYNTHESIS指令及文本数据，服务端则异步返回两种数据：
   • 二进制音频流：通过WebSocket的Binary Message帧发送，是原始的PCM或MP3音频数据。
   • 文本元信息：通过Text Message帧发送JSON，包含合成状态、错误码、以及如果开启了字幕功能，还会包含每个字的时间戳信息。
4. 结束（FINAL）阶段：客户端发送完所有文本后，发送ACTION_COMPLETE指令。服务端合成完缓存中的所有文本后，返回final字段为1的消息，客户端随后主动关闭连接。

注意：一个常见的误解是认为“流式”仅仅指音频流式返回。实际上，腾讯云流式TTS是“双流”模式：文本输入流和音频输出流。这要求客户端必须具备异步处理和缓冲区管理的能力。

2. 从零构建Unity流式TTS客户端

理论清晰后，我们进入实战环节。我将以一个Unity引擎中的C#实现为例，演示如何构建一个健壮的流式TTS客户端。选择Unity是因为它在游戏、虚拟人、XR应用中广泛使用，对实时音频处理的需求很高。其中的核心逻辑同样适用于Web前端、移动端等其他平台。

2.1 项目准备与依赖管理

首先，确保你的Unity项目已准备好网络通信和JSON处理的基础设施。

1. WebSocket库：Unity原生不支持WebSocket，我们需要第三方库。除了原始资料中提到的BestHTTP，WebSocketSharp或NativeWebSocket也是流行且稳定的选择。这里以NativeWebSocket为例，可以通过Unity的Package Manager从Git URL添加。

   https://github.com/endel/NativeWebSocket.git
   

2. JSON库：Unity自带的JsonUtility功能较弱，对于嵌套对象和数组处理不便。强烈推荐使用Newtonsoft.Json（即Json.NET），功能强大，社区支持好。可以通过Unity的Package Manager搜索Newtonsoft Json安装。

3. 权限配置：如果你的项目目标是PC、Mac或移动平台，通常无需额外配置。如果目标是WebGL，需要在Player Settings中启用WebSocket支持。

2.2 核心管理器类设计与实现

我们将创建一个TencentCloudStreamingTTSManager单例类来封装所有流式TTS逻辑。这个类的设计目标是高内聚、低耦合，便于在项目的任何地方调用。

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;
using NativeWebSocket; // 或其他WebSocket库
using Newtonsoft.Json;

public class TencentCloudStreamingTTSManager : MonoBehaviour
{
    public static TencentCloudStreamingTTSManager Instance { get; private set; }

    // 配置参数（应从安全的位置加载，如ScriptableObject或服务器）
    [Header("腾讯云配置")]
    [SerializeField] private string _appId = "YOUR_APP_ID";
    [SerializeField] private string _secretId = "YOUR_SECRET_ID";
    [SerializeField] private string _secretKey = "YOUR_SECRET_KEY";

    [Header("合成参数")]
    [SerializeField] private int _voiceType = 101001; // 101001: 精品女声
    [SerializeField] private float _speed = 0f; // 语速，范围[-2, 6]
    [SerializeField] private float _volume = 0f; // 音量，范围[-10, 10]
    [SerializeField] private int _sampleRate = 16000; // 音频采样率
    [SerializeField] private bool _enableSubtitle = true; // 是否开启时间戳

    private WebSocket _webSocket;
    private string _sessionId;
    private bool _isReadyToSynthesize = false;
    private Queue<string> _textQueue = new Queue<string>();
    private StringBuilder _receivedTextBuffer = new StringBuilder();
    private List<byte> _audioBuffer = new List<byte>();
    private AudioSource _audioSource; // 用于播放音频的组件

    // 定义事件，方便其他脚本订阅状态
    public event Action OnConnectionOpened;
    public event Action<string> OnConnectionError;
    public event Action OnReadyForSynthesis;
    public event Action<AudioClip, string> OnAudioClipGenerated; // 返回音频片段和对应文本
    public event Action<string> OnSubtitleReceived; // 收到字幕信息（如果开启）

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
        _audioSource = gameObject.AddComponent<AudioSource>();
    }

    // 外部调用的入口：初始化并连接TTS服务
    public async void InitializeAndConnect()
    {
        if (_webSocket != null && _webSocket.State == WebSocketState.Open)
        {
            Debug.LogWarning("WebSocket连接已存在。");
            return;
        }

        _sessionId = Guid.NewGuid().ToString();
        string url = BuildWebSocketUrl();
        _webSocket = new WebSocket(url);

        // 订阅WebSocket事件
        _webSocket.OnOpen += HandleWebSocketOpen;
        _webSocket.OnMessage += HandleWebSocketMessage;
        _webSocket.OnError += HandleWebSocketError;
        _webSocket.OnClose += HandleWebSocketClose;

        await _webSocket.Connect();
    }
}

在上面的代码中，我们定义了管理器的基本骨架，包括配置字段、状态变量和核心事件。InitializeAndConnect方法是启动整个流程的入口。

2.3 签名生成与URL构建

这是与腾讯云API交互的第一步，也是最容易出错的一步。签名错误将直接导致连接失败。我们必须严格按照官方文档的步骤生成签名。

private string BuildWebSocketUrl()
{
    // 1. 生成时间戳和过期时间
    var now = DateTimeOffset.UtcNow;
    long timestamp = now.ToUnixTimeSeconds();
    long expired = timestamp + 86400; // 签名有效期1天

    // 2. 按参数名ASCII码从小到大排序（字典序）
    var paramDict = new SortedDictionary<string, string>(StringComparer.Ordinal)
    {
        {"Action", "TextToStreamAudioWSv2"},
        {"AppId", _appId},
        {"Codec", "pcm"},
        {"EnableSubtitle", _enableSubtitle.ToString()},
        {"Expired", expired.ToString()},
        {"SampleRate", _sampleRate.ToString()},
        {"SecretId", _secretId},
        {"SessionId", _sessionId},
        {"Speed", _speed.ToString()},
        {"Timestamp", timestamp.ToString()},
        {"VoiceType", _voiceType.ToString()},
        {"Volume", _volume.ToString()}
    };

    // 3. 拼接请求参数字符串
    var paramBuilder = new StringBuilder();
    foreach (var kvp in paramDict)
    {
        if (paramBuilder.Length > 0) paramBuilder.Append('&');
        paramBuilder.Append($"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}");
    }
    string paramStr = paramBuilder.ToString();

    // 4. 拼接签名原文字符串（格式固定）
    string signatureOriginal = $"GETtts.cloud.tencent.com/stream_wsv2?{paramStr}";

    // 5. 使用HMAC-SHA1加密并Base64编码
    string signature;
    using (var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(_secretKey)))
    {
        byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(signatureOriginal));
        signature = Convert.ToBase64String(hash);
    }

    // 6. 对Signature进行URL编码并拼接最终URL
    signature = Uri.EscapeDataString(signature);
    string finalUrl = $"wss://tts.cloud.tencent.com/stream_wsv2?{paramStr}&Signature={signature}";

    Debug.Log($"构建的WebSocket URL: {finalUrl}");
    return finalUrl;
}

关键提示：签名原文字符串的格式必须严格为 GETtts.cloud.tencent.com/stream_wsv2?{paramStr}。注意GET后面没有空格，也没有https://协议头。这是腾讯云签名算法V1版本的要求，一个字符的错误都会导致鉴权失败。

3. 攻克核心难题：音频流的接收、拼接与无杂音播放

连接建立后，真正的挑战才开始。流式TTS会源源不断地送来小段的PCM音频数据。如何将这些数据块平滑地拼接成连续的音频流并播放，同时避免产生“咔哒”声或“噗噗”声等异响，是体验好坏的决定性因素。

3.1 音频数据接收与缓冲策略

服务端返回的二进制数据是原始的16位有符号PCM数据（如果Codec参数设为pcm）。我们需要一个缓冲区来累积这些数据，直到达到一个合理的长度再转换为Unity的AudioClip进行播放。

private void HandleWebSocketMessage(byte[] data)
{
    // 收到的二进制数据是PCM音频流
    lock (_audioBuffer)
    {
        _audioBuffer.AddRange(data);
    }

    // 策略：当缓冲区累积到一定时长（如0.5秒）的音频数据时，进行转换和播放
    // 计算0.5秒对应的字节数: 采样率 * 通道数 * (位深/8) * 时长(秒)
    // 16位PCM，单声道，所以是 2 bytes per sample
    int bytesPerSecond = _sampleRate * 1 * 2;
    int thresholdBytes = bytesPerSecond / 2; // 0.5秒的数据量

    if (_audioBuffer.Count >= thresholdBytes)
    {
        ProcessAudioBuffer();
    }
}

private void ProcessAudioBuffer()
{
    byte[] dataToProcess;
    lock (_audioBuffer)
    {
        if (_audioBuffer.Count == 0) return;
        dataToProcess = _audioBuffer.ToArray();
        _audioBuffer.Clear(); // 清空缓冲区，准备接收新数据
    }

    // 将PCM字节数组转换为float数组（Unity AudioClip所需格式）
    float[] floatData = new float[dataToProcess.Length / 2];
    for (int i = 0; i < floatData.Length; i++)
    {
        // 假设字节序为小端序（Little-Endian）
        short intSample = (short)((dataToProcess[i * 2 + 1] << 8) | dataToProcess[i * 2]);
        floatData[i] = intSample / 32768.0f; // 将16位有符号整数归一化到[-1.0, 1.0]
    }

    // 创建AudioClip并播放
    AudioClip newClip = AudioClip.Create(
        $"TTS_Audio_{Time.time}",
        floatData.Length,
        1, // 声道数
        _sampleRate,
        false // 非流式，一次性设置数据
    );
    newClip.SetData(floatData, 0);

    // 触发事件，通知其他组件新的音频片段已就绪
    OnAudioClipGenerated?.Invoke(newClip, _receivedTextBuffer.ToString());
    _receivedTextBuffer.Clear(); // 清空已处理的文本缓冲区

    // 使用AudioSource播放（这里采用简单的队列播放，更复杂的方案见下文）
    PlayAudioClip(newClip);
}

这个基础方案存在一个明显问题：如果ProcessAudioBuffer和播放的速度跟不上数据接收的速度，会导致缓冲区堆积，延迟越来越大。反之，如果处理太快，缓冲区数据不足，又会造成播放卡顿。

3.2 消除拼接异响的终极方案：交叉淡入淡出

原始资料中提到的“音频拼接后播放会出现声音异响一声”，其根源在于音频片段连接处的不连续。两个PCM片段的末尾和开头可能处于不同的振幅相位，直接拼接会产生可闻的“咔哒”声或爆破音。

解决方案是音频交叉淡入淡出。在播放当前片段的同时，提前准备好下一个片段，并在两者重叠的部分进行音量渐变，实现无缝过渡。

我们需要一个更高级的音频播放管理器：

public class SeamlessAudioPlayer : MonoBehaviour
{
    private List<AudioClip> _clipQueue = new List<AudioClip>();
    private List<AudioSource> _audioSources = new List<AudioSource>();
    private int _currentSourceIndex = 0;
    private float _crossFadeDuration = 0.05f; // 交叉淡入淡出时长，50毫秒

    void Start()
    {
        // 创建两个AudioSource用于交叉播放
        for (int i = 0; i < 2; i++)
        {
            var source = gameObject.AddComponent<AudioSource>();
            source.playOnAwake = false;
            _audioSources.Add(source);
        }
    }

    public void ScheduleClip(AudioClip clip)
    {
        _clipQueue.Add(clip);
        if (!IsPlaying())
        {
            PlayNextClip();
        }
        else if (_clipQueue.Count == 1)
        {
            // 如果只有一个在排队，且正在播放，则准备交叉淡入淡出
            StartCoroutine(PrepareCrossFade());
        }
    }

    private bool IsPlaying()
    {
        return _audioSources[0].isPlaying || _audioSources[1].isPlaying;
    }

    private void PlayNextClip()
    {
        if (_clipQueue.Count == 0) return;

        AudioClip nextClip = _clipQueue[0];
        _clipQueue.RemoveAt(0);

        AudioSource nextSource = _audioSources[_currentSourceIndex];
        nextSource.clip = nextClip;
        nextSource.Play();

        _currentSourceIndex = (_currentSourceIndex + 1) % 2;
    }

    private System.Collections.IEnumerator PrepareCrossFade()
    {
        AudioSource currentSource = _audioSources[(_currentSourceIndex + 1) % 2]; // 当前正在播放的源
        AudioSource nextSource = _audioSources[_currentSourceIndex]; // 即将播放的源

        AudioClip nextClip = _clipQueue[0];
        _clipQueue.RemoveAt(0);
        nextSource.clip = nextClip;

        // 计算交叉淡入淡出开始的时间点
        float startFadeTime = currentSource.clip.length - _crossFadeDuration;

        yield return new WaitForSeconds(startFadeTime);

        // 开始交叉淡入淡出
        StartCoroutine(CrossFade(currentSource, nextSource, _crossFadeDuration));
    }

    private System.Collections.IEnumerator CrossFade(AudioSource fadeOutSource, AudioSource fadeInSource, float duration)
    {
        float timer = 0f;
        fadeInSource.volume = 0f;
        fadeInSource.Play();

        while (timer < duration)
        {
            timer += Time.deltaTime;
            float ratio = timer / duration;
            fadeOutSource.volume = Mathf.Lerp(1f, 0f, ratio);
            fadeInSource.volume = Mathf.Lerp(0f, 1f, ratio);
            yield return null;
        }

        fadeOutSource.Stop();
        fadeOutSource.volume = 1f; // 重置音量供下次使用
    }
}

将这个SeamlessAudioPlayer组件挂载到你的管理器GameObject上，并在OnAudioClipGenerated事件中调用ScheduleClip方法。通过两个AudioSource的交替工作和短暂的音量渐变，可以彻底消除片段间的拼接噪音，获得广播级的平滑听觉体验。

3.3 文本流与音频流的同步与字幕处理

流式TTS的另一个优势是能返回精确到字级别的时间戳信息（需设置EnableSubtitle=true）。这为实现精准的字幕同步提供了可能。

当收到服务端的文本消息（JSON格式）时，我们解析其中的subtitles字段：

private void HandleWebSocketMessage(string message)
{
    Debug.Log($"收到文本消息: {message}");
    try
    {
        var response = JsonConvert.DeserializeObject<TTSResponse>(message);

        if (response.code != 0)
        {
            Debug.LogError($"TTS服务返回错误: {response.code} - {response.message}");
            OnConnectionError?.Invoke($"服务端错误: {response.message}");
            return;
        }

        if (response.ready == 1)
        {
            _isReadyToSynthesize = true;
            OnReadyForSynthesis?.Invoke();
            Debug.Log("服务端已就绪，可以开始发送合成文本。");
        }

        if (response.final == 1)
        {
            Debug.Log("所有文本合成完毕。");
            // 处理缓冲区剩余的音频数据
            if (_audioBuffer.Count > 0)
            {
                ProcessAudioBuffer();
            }
            // 可以在这里安全地关闭连接
            _webSocket?.Close();
            return;
        }

        // 处理字幕信息
        if (response.result?.subtitles != null && response.result.subtitles.Length > 0)
        {
            foreach (var subtitle in response.result.subtitles)
            {
                // 这里可以驱动UI，实现高亮或滚动字幕
                OnSubtitleReceived?.Invoke(subtitle.Text);
                // 利用BeginTime和EndTime可以实现更精确的同步
                // Debug.Log($"字: {subtitle.Text}, 开始: {subtitle.BeginTime}ms, 结束: {subtitle.EndTime}ms");
            }
        }
    }
    catch (Exception ex)
    {
        Debug.LogError($"解析TTS响应失败: {ex.Message}");
    }
}

// 定义响应数据模型
[System.Serializable]
public class TTSResponse
{
    public int code;
    public string message;
    public string session_id;
    public string request_id;
    public string message_id;
    public int ready;
    public int final;
    public int heartbeat;
    public ResultData result;
}

[System.Serializable]
public class ResultData
{
    public SubtitleData[] subtitles;
}

[System.Serializable]
public class SubtitleData
{
    public string Text;
    public int BeginTime;
    public int EndTime;
    public int BeginIndex;
    public int EndIndex;
    public string Phoneme;
}

通过解析BeginTime和EndTime，你可以精确控制UI中每个字的显示时机，实现与语音高度同步的卡拉OK式字幕效果，极大增强沉浸感。

4. 高级调优与生产环境避坑指南

掌握了基础实现和核心难题的解决方案后，我们还需要关注一些高级调优技巧和在生产环境中可能遇到的“坑”。

4.1 参数调优：让合成效果更自然

腾讯云流式TTS提供了丰富的参数来控制合成效果。盲目使用默认值可能无法达到最佳体验。

• 语速（Speed）：范围[-2, 6]。0是正常语速。对于大模型的逐字播报，我建议设置在0到1之间（1.0倍到1.2倍）。过快的语速在流式播放时会让用户感到紧张，过慢则显得拖沓。对于新闻播报类内容，可以稍快（1.2），对于故事或对话，可以稍慢（0.8）。
• 音量（Volume）：范围[-10, 10]。0是标准音量。在嘈杂环境中（如车载设备），可以适当提高到2或3。注意，过高的音量可能导致音频削波（Clipping），产生失真。
• 情感控制（EmotionCategory & EmotionIntensity）：这是高级功能，仅对支持多情感的音色生效。例如，在虚拟客服场景中，可以设置EmotionCategory为"call"（客服），EmotionIntensity为120，让声音听起来更亲切、更有服务感。在讲故事时，可以尝试"story"（故事）情感。
• 断句敏感度（SegmentRate）：范围[0,1,2]，默认0。这个参数控制模型对句子边界的判断。如果发现合成语音在不该停顿的地方停顿（比如长句中），可以尝试将其设为1或2，让模型更倾向于只在标点处断句。此参数对合成流畅度影响很大，建议根据实际文本内容进行微调。

实战经验：不同的音色ID对参数的敏感度不同。例如，一些更“活泼”的青年女声音色，稍微提高语速（Speed=1）会显得更有活力。而一些沉稳的男声音色，保持默认语速或稍慢（Speed=-0.5）效果更好。最好的方法是建立一个参数测试集，用你的实际业务文本对不同音色进行批量测试，记录下最优组合。

4.2 连接管理与错误重试机制

网络是不稳定的，WebSocket连接可能意外中断。一个健壮的生产级系统必须具备重连能力。

private int _reconnectAttempts = 0;
private const int MAX_RECONNECT_ATTEMPTS = 3;

private async void HandleWebSocketClose(WebSocketCloseCode closeCode)
{
    Debug.Log($"WebSocket连接关闭，代码: {closeCode}");
    _isReadyToSynthesize = false;

    // 如果不是正常结束，且重试次数未超限，则尝试重连
    if (closeCode != WebSocketCloseCode.Normal && _reconnectAttempts < MAX_RECONNECT_ATTEMPTS)
    {
        _reconnectAttempts++;
        Debug.Log($"尝试第{_reconnectAttempts}次重连...");
        await Task.Delay(1000 * _reconnectAttempts); // 指数退避
        InitializeAndConnect();
    }
    else if (_reconnectAttempts >= MAX_RECONNECT_ATTEMPTS)
    {
        Debug.LogError($"重连{MAX_RECONNECT_ATTEMPTS}次均失败，请检查网络或服务状态。");
        OnConnectionError?.Invoke("连接已断开，且重连失败。");
    }
}

private void HandleWebSocketError(string errorMsg)
{
    Debug.LogError($"WebSocket错误: {errorMsg}");
    OnConnectionError?.Invoke($"连接错误: {errorMsg}");
}

此外，还需要处理服务端返回的特定错误码。例如，错误码10009表示“流式输入文本超时未发送”，这通常是因为客户端超过10分钟没有发送新的文本。在长时间等待用户输入的对话场景中，需要实现一个“心跳”或“保活”机制，定期发送空数据或特定指令来保持连接。

4.3 性能优化与内存管理

在Unity中，频繁创建和销毁AudioClip对象可能引发GC（垃圾回收）压力，导致卡顿。

• 对象池：为AudioClip或用于播放的GameObject建立对象池，复用而不是销毁。
• 缓冲区复用：避免在每次处理音频时都new byte[]或new float[]。可以维护一个固定大小的循环缓冲区，或者使用ArrayPool<T>来租用数组。
• 异步操作：将PCM数据转换为AudioClip的过程（Create和SetData）是CPU密集型的，可以考虑放在单独的线程或使用UnityJobSystem、Burst编译器来加速，避免阻塞主线程。

// 简化的对象池示例
public class AudioClipPool
{
    private Queue<AudioClip> _pool = new Queue<AudioClip>();
    private int _clipSamples; // 假设池中所有Clip长度固定

    public AudioClipPool(int poolSize, int samples, int channels, int frequency)
    {
        _clipSamples = samples;
        for (int i = 0; i < poolSize; i++)
        {
            AudioClip clip = AudioClip.Create($"PooledAudioClip_{i}", samples, channels, frequency, false);
            _pool.Enqueue(clip);
        }
    }

    public AudioClip Get()
    {
        if (_pool.Count > 0)
        {
            return _pool.Dequeue();
        }
        // 池为空，动态创建一个（应尽量避免）
        return AudioClip.Create("DynamicAudioClip", _clipSamples, 1, 16000, false);
    }

    public void Return(AudioClip clip)
    {
        // 可以在这里重置Clip的数据（如果需要）
        // clip.SetData(new float[clip.samples * clip.channels], 0);
        _pool.Enqueue(clip);
    }
}

4.4 与LLM文本流的协同工作流

最后，如何将流式TTS与你的大语言模型（如GPT、文心一言等）的输出流优雅地结合？关键在于设计一个高效的文本流处理器。

大模型通常是按“词元”（token）或“字”流式返回的。直接每收到一个字就调用TTS发送，会产生大量微小请求，效率低下且可能触发服务端的频率限制。更佳的策略是进行缓冲和智能分段。

public class LLMStreamProcessor : MonoBehaviour
{
    private StringBuilder _sentenceBuffer = new StringBuilder();
    private TencentCloudStreamingTTSManager _ttsManager;

    void Start()
    {
        _ttsManager = TencentCloudStreamingTTSManager.Instance;
        // 假设你有一个订阅LLM token流的事件
        YourLLMService.OnTokenReceived += HandleToken;
    }

    private void HandleToken(string token)
    {
        _sentenceBuffer.Append(token);

        // 智能分段逻辑：遇到句号、问号、感叹号、分号、换行符时，认为一个句子结束
        char lastChar = token[token.Length - 1];
        if (IsSentenceEndPunctuation(lastChar) || _sentenceBuffer.Length > 50) // 同时设置最大长度限制
        {
            string sentenceToSend = _sentenceBuffer.ToString();
            _sentenceBuffer.Clear();

            if (_ttsManager.IsReady)
            {
                _ttsManager.SynthesizeText(sentenceToSend);
            }
            else
            {
                // 如果TTS未就绪，可以先缓存起来
                Debug.LogWarning("TTS未就绪，句子已缓存。");
            }
        }
    }

    private bool IsSentenceEndPunctuation(char c)
    {
        return c == '。' || c == '？' || c == '！' || c == '；' || c == '\n' || c == '.' || c == '?' || c == '!';
    }

    // 当LLM流结束时，强制发送缓冲区剩余内容
    public void FlushBuffer()
    {
        if (_sentenceBuffer.Length > 0)
        {
            _ttsManager.SynthesizeText(_sentenceBuffer.ToString());
            _sentenceBuffer.Clear();
        }
        // 发送结束指令
        _ttsManager.CompleteSynthesis();
    }
}

这个处理器会积累LLM返回的token，直到遇到合适的句子边界或达到一定长度，才将整句发送给TTS。这样既保证了语音的连贯性（避免在词组中间停顿），又减少了网络请求次数。