Премини към основното съдържание
Български— Изберете език
Меню

Потоково предаване на аудио в реално време

Урок 12 от 18 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Потоково предаване на аудио в реално време
  2. Потоково предаване с TTS API
  3. Измерване на латентността
  4. Асинхронно потоково предаване
  5. Предварително запълване на буфера
  6. Интегриране с конвейер LLM + TTS
  7. Ключови изводи

Актуализация от 2 ноември 2026 г. — Аудио модели. Няколко модела в този курс са депрецирали: tts-1, tts-1-hd и gpt-4o-mini-tts ще спрат да работят на 6 януари 2027 г. (наследник: gpt-realtime-2.1-mini, който според ръководството на OpenAI за TTS не се поддържа от /v1/audio/speech: миграцията на синтез на глас преминава към Realtime API); gpt-realtime, gpt-4o-realtime и наследените аудио модели на 20 януари 2027 г. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe и /v1/audio/translations на 26 февруари 2027 г. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). За дуплексна гласова връзка, GPT-Live 1 е достъпен в API от 10 септември 2026 г. Актуализирано на 3 ноември 2026 г.: Потокът LLM → TTS преди това обработваше всяко събитие, съдържащо поле delta, включително аргументи за извикване на функции или обобщения на разсъжденията; сега филтрира строго за response.output_text.delta, което представлява действителния текст на отговора.

Потоково предаване на аудио в реално време

При гласов агент, изчакването на генерирането на целия аудио файл преди започване на възпроизвеждането въвежда неприемлива латентност. Потоковото предаване на TTS Ви позволява да започнете възпроизвеждането веднага щом пристигнат първите байтове, намалявайки времето до първия отговор до няколкостотин милисекунди.

Потоково предаване с TTS API

TTS API поддържа потоково предаване нативно. Вместо да чакате пълния файл, получавате аудио на части:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Генериране и възпроизвеждане на аудио в режим на потоково предаване."""
    # Инициализиране на аудио плейъра
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Създаване на потоковия отговор
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Суров PCM за директно възпроизвеждане
        ) as response:
            # Четене и възпроизвеждане част по част
            for chunk in response.iter_bytes(chunk_size=4096):
                player.write(chunk)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

stream_tts_to_speaker("Hello, here is a real-time streaming response.")

Форматът pcm е идеален за потоково предаване, тъй като не изисква декодиране: суровите байтове са готови за възпроизвеждане незабавно.

Измерване на латентността

Времето до първия байт (TTFB) е ключовият показател за производителността при потоково предаване:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Измерване на латентностите при TTS потоково предаване."""
    start_time = time.time()
    first_byte_time = None
    total_bytes = 0

    with client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        for chunk in response.iter_bytes(chunk_size=4096):
            if first_byte_time is None:
                first_byte_time = time.time()
            total_bytes += len(chunk)

    end_time = time.time()

    return {
        "ttfb_ms": round((first_byte_time - start_time) * 1000),
        "total_ms": round((end_time - start_time) * 1000),
        "total_bytes": total_bytes,
        "audio_duration_s": round(total_bytes / (24000 * 2), 2)
    }

metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")

Асинхронно потоково предаване

За сървърни приложения използвайте асинхронния клиент:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Асинхронно TTS потоково предаване за сървъри."""
    chunks = []

    async with async_client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        async for chunk in response.iter_bytes(chunk_size=4096):
            chunks.append(chunk)
            # Тук бихте изпратили частта към клиента чрез WebSocket
            yield chunk

# Използване в FastAPI сървър
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
    return StreamingResponse(
        stream_tts_async(text, voice),
        media_type="audio/pcm"
    )

Предварително запълване на буфера

За да осигурите плавно възпроизвеждане без прекъсвания, натрупайте малък буфер преди стартиране:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Брой части за предварително зареждане
):
    """TTS възпроизвеждане с буфер за предварително запълване."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    buffer = []
    playback_started = False

    try:
        async with async_client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"
        ) as response:
            async for chunk in response.iter_bytes(chunk_size=4096):
                buffer.append(chunk)

                if not playback_started and len(buffer) >= buffer_size:
                    playback_started = True
                    # Изпразване на началния буфер
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Възпроизвеждане на останалите части
        for remaining in buffer:
            player.write(remaining)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Интегриране с конвейер LLM + TTS

В гласов агент, който не използва Realtime API, можете да комбинирате потоковото предаване на LLM с това на TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Конвейер: Потоково LLM → Потоково TTS в реално време."""
    # Фаза 1: Натрупване на отговора от LLM по изречения
    sentence_buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-luna",
        input=[{"role": "user", "content": user_message}],
        stream=True
    )

    for event in stream:
        # Само текстът на отговора трябва да бъде изговорен
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Откриване на края на изречението
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Фаза 2: Потоково предаване на това изречение към TTS
                stream_tts_to_speaker(sentence)

    # Обработка на останалия буфер
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Ключови изводи

  • Потоковото предаване на TTS намалява TTFB до няколкостотин милисекунди, като започва възпроизвеждането преди приключване на генерирането
  • Форматът pcm е оптимален за потоково предаване: не изисква декодиране, директно възпроизвеждане
  • Буфер за предварително запълване от 2–3 части предотвратява прекъсванията в началото на възпроизвеждането
  • Асинхронният клиент е от съществено значение за сървъри, обработващи множество едновременни връзки
  • Комбинирането на потоково LLM и потоково TTS позволява създаването на отзивчив гласов агент без използването на Realtime API