Streamování zvuku v reálném čase
Na této stránce
Aktualizace 2. listopadu 2026 — Zvukové modely. Několik modelů v tomto kurzu je zastaralých:
tts-1,tts-1-hdagpt-4o-mini-ttspř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-realtimea starší zvukové modely 20. ledna 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribea/v1/audio/translations26. ú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í poledelta, včetně argumentů volání funkcí nebo shrnutí úvah; nyní filtruje striktně pouzeresponse.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
pcmje 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