Streamovanie zvuku v reálnom čase
Na tejto strane
Aktualizácia 2. novembra 2026 — Zvukové modely. Niektoré modely v tomto kurze sú zastarané:
tts-1,tts-1-hdagpt-4o-mini-ttsprestanú 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-realtimea 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-transcribea/v1/audio/translations26. 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 poledelta, vrátane argumentov volania funkcií alebo zhrnutí úvah; teraz filtruje striktne podľaresponse.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
pcmje 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