Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Streamování zvuku v reálném čase

Lekce 12 z 18 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Streamování zvuku v reálném čase
  2. Streamování pomocí TTS API
  3. Měření latence
  4. Asynchronní streamování
  5. Předběžné naplnění vyrovnávací paměti
  6. Integrace s pipeline LLM + TTS
  7. Klíčové poznatky

Aktualizace 2. listopadu 2026 — Zvukové modely. Několik modelů v tomto kurzu je zastaralých: tts-1, tts-1-hd a gpt-4o-mini-tts přestanou fungovat 6. ledna 2027 (nástupce: gpt-realtime-2.1-mini, který podle průvodce OpenAI TTS není podporován rozhraním /v1/audio/speech: migrace syntézy hlasu přechází na Realtime API); gpt-realtime, gpt-4o-realtime a starší zvukové modely 20. ledna 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe a /v1/audio/translations 26. února 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pro plně duplexní hlas je GPT-Live 1 dostupné v API od 10. září 2026. Aktualizováno 3. listopadu 2026: Pipeline LLM → TTS dříve zpracovávala jakoukoli událost obsahující pole delta, včetně argumentů volání funkcí nebo shrnutí úvah; nyní filtruje striktně pouze response.output_text.delta, tedy skutečný text odpovědi.

Streamování zvuku v reálném čase

U hlasového agenta čekání na vygenerování celého zvukového souboru před spuštěním přehrávání zavádí nepřijatelnou latenci. Streamování TTS ti umožňuje zahájit přehrávání, jakmile dorazí první bajty, čímž zkracuje dobu do první odpovědi na několik set milisekund.

Streamování pomocí TTS API

TTS API podporuje streamování nativně. Místo čekání na kompletní soubor přijímáš zvuk po částech (chuncích):

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generování a přehrávání zvuku v režimu streamování."""
    # Inicializace přehrávače zvuku
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Vytvoření streamované odpovědi
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Surové PCM pro přímé přehrávání
        ) as response:
            # Čtení a přehrávání po částech
            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.")

Formát pcm je ideální pro streamování, protože nevyžaduje žádné dekódování: surová bajtová data jsou připravena k okamžitému přehrání.

Měření latence

Klíčovou metrikou pro výkon streamování je doba do prvního bajtu (TTFB – Time to First Byte):

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Měření latencí streamování 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")

Asynchronní streamování

Pro serverové aplikace použij asynchronního klienta:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asynchronní streamování TTS pro servery."""
    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)
            # Zde bys odeslal chunk klientovi přes WebSocket
            yield chunk

# Použití v serveru 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"
    )

Předběžné naplnění vyrovnávací paměti

Aby bylo přehrávání plynulé bez mezer, nahromadi před spuštěním malou vyrovnávací paměť (buffer):

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Počet chunků k předběžnému načtení
):
    """Přehrávání TTS s předběžně naplněným buffrem."""
    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
                    # Vyprázdnění počátečního bufferu
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Přehrání zbývajících chunků
        for remaining in buffer:
            player.write(remaining)

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

Integrace s pipeline LLM + TTS

U hlasového agenta, který nepoužívá Realtime API, můžeš kombinovat streamování LLM se streamováním TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Streamování LLM → Streamování TTS v reálném čase."""
    # Fáze 1: Akumulace odpovědi LLM po větách
    sentence_buffer = ""

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

    for event in stream:
        # Mluven by měl být pouze text odpovědi
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detekce konce věty
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fáze 2: Streamování této věty do TTS
                stream_tts_to_speaker(sentence)

    # Zpracování zbytku bufferu
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Klíčové poznatky

  • Streamování TTS zkracuje TTFB na několik set milisekund tím, že zahájí přehrávání před dokončením generování
  • Formát pcm je pro streamování optimální: nevyžaduje dekódování, umožňuje přímé přehrávání
  • Předběžný buffer o velikosti 2–3 chunků zabraňuje mezerám na začátku přehrávání
  • Asynchronní klient je nezbytný pro servery obsluhující více současných připojení
  • Kombinace streamování LLM a streamování TTS umožňuje vytvořit responzivního hlasového agenta i bez použití Realtime API