Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Streamovanie zvuku v reálnom čase

Lekcia 12 z 18 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Streamovanie zvuku v reálnom čase
  2. Streamovanie pomocou TTS API
  3. Meranie latencie
  4. Asynchrónne streamovanie
  5. Predbežné naplnenie vyrovnávacej pamäte
  6. Integrácia s pipeline LLM + TTS
  7. Kľúčové poznatky

Aktualizácia 2. novembra 2026 — Zvukové modely. Niektoré modely v tomto kurze sú zastarané: tts-1, tts-1-hd a gpt-4o-mini-tts prestanú fungovať 6. januára 2027 (nástupca: gpt-realtime-2.1-mini, ktorý podľa príručky OpenAI TTS nie je podporovaný rozhraním /v1/audio/speech: migrácia syntézy hlasu prechádza na Realtime API); gpt-realtime, gpt-4o-realtime a staršie zvukové modely 20. januára 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe a /v1/audio/translations 26. februára 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pre plno duplexný hlas je GPT-Live 1 dostupné v API od 10. septembra 2026. Aktualizované 3. novembra 2026: Pipeline LLM → TTS predtým spracovávala akúkoľvek udalosť obsahujúcu pole delta, vrátane argumentov volania funkcií alebo zhrnutí úvah; teraz filtruje striktne podľa response.output_text.delta, čo je skutočný text odpovede.

Streamovanie zvuku v reálnom čase

Pri hlasovom agentovi čakanie na vygenerovanie celého zvukového súboru pred začatím prehrávania prináša neprijateľnú latenciu. Streamovanie TTS ti umožňuje začať prehrávanie hneď, ako dorazia prvé bajty, čím sa čas do prvej odpovede skracuje na niekoľko stoviek milisekúnd.

Streamovanie pomocou TTS API

TTS API podporuje streamovanie natívne. Namiesto čakania na kompletný súbor dostávaš zvuk po častiach:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generovanie a prehrávanie zvuku v režime streamovania."""
    # Inicializácia prehrávača zvuku
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Vytvorenie streamovacej odpovede
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Surové PCM pre priame prehrávanie
        ) as response:
            # Čítanie a prehrávanie po častiach
            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álny pre streamovanie, pretože nevyžaduje žiadne dekódovanie: surové bajty sú pripravené na okamžité prehratie.

Meranie latencie

Čas do prvého bajtu (TTFB) je kľúčovým ukazovateľom výkonu streamovania:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Meranie latencií streamovania 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")

Asynchrónne streamovanie

Pre aplikácie na strane servera použij asynchrónneho klienta:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asynchrónne streamovanie TTS pre 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)
            # Tu by si odoslal časť klientovi cez WebSocket
            yield chunk

# Použitie v serveri 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"
    )

Predbežné naplnenie vyrovnávacej pamäte

Aby si zabezpečil plynulé prehrávanie bez medzier, pred začatím nazhromaždi malú vyrovnávaciu pamäť:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Počet častí na predbežné načítanie
):
    """Prehrávanie TTS s predbežne naplnenou vyrovnávacou pamäťou."""
    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ázdnenie počiatočnej vyrovnávacej pamäte
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Prehratie zostávajúcich častí
        for remaining in buffer:
            player.write(remaining)

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

Integrácia s pipeline LLM + TTS

V hlasovom agentovi, ktorý nepoužíva Realtime API, môžeš kombinovať streamovanie LLM so streamovaním TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Streamovanie LLM → Streamovanie TTS v reálnom čase."""
    # Fáza 1: Akumulácia odpovede LLM po vetách
    sentence_buffer = ""

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

    for event in stream:
        # Hovoriť by sa mal iba text odpovede
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detekcia konca vety
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fáza 2: Streamovanie tejto vety do TTS
                stream_tts_to_speaker(sentence)

    # Spracovanie zostávajúcej vyrovnávacej pamäte
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Kľúčové poznatky

  • Streamovanie TTS znižuje TTFB na niekoľko stoviek milisekúnd tým, že začne prehrávanie ešte pred dokončením generovania
  • Formát pcm je optimálny pre streamovanie: nevyžaduje dekódovanie, umožňuje priame prehrávanie
  • Predbežné naplnenie vyrovnávacej pamäte o 2–3 časti zabraňuje medzerám na začiatku prehrávania
  • Asynchrónny klient je nevyhnutný pre servery obsluhujúce viacero súčasných pripojení
  • Kombinácia streamovania LLM a streamovania TTS umožňuje vytvoriť responzívneho hlasového agenta aj bez použitia Realtime API