Valós idejű audió streaming
Ezen az oldalon
Frissítés: 2026. november 2. — Audió modellek. A tanfolyam több modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-tts2027. január 6-án megszűnik működni (utód:gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint nem támogat a/v1/audio/speech: a hangszintézis migrációja a Realtime API felé történik); agpt-realtime,gpt-4o-realtimeés a régi audió modellek 2027. január 20-án (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translations2027. február 26-án (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban. Frissítve: 2026. november 3.: Az LLM → TTS folyamat korábban minden olyan eseményt feldolgozott, amelydeltamezőt tartalmazott, beleértve a függvényhívási argumentumokat vagy az érvelési összefoglalókat is; most már szigorúan csak aresponse.output_text.delta, azaz a tényleges válaszszöveg esetén szűr.
Valós idejű audió streaming
Egy hangalapú ügynöknél elfogadhatatlan késleltetést okoz, ha megvárod a teljes hangfájl generálását a lejátszás megkezdése előtt. A TTS streaming lehetővé teszi, hogy az első bájtok megérkezésekor azonnal elindítsd a lejátszást, ezzel néhány száz milliszekundumra csökkentve az első válasz idejét.
Streaming a TTS API-val
A TTS API natívan támogatja a streaminget. A teljes fájlra való várakozás helyett darabokban (chunkokban) kapod meg az audiót:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Hang generálása és lejátszása streaming módban."""
# Hanglejátszó inicializálása
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Streaming válasz létrehozása
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Nyers PCM a közvetlen lejátszáshoz
) as response:
# Darabonkénti olvasás és lejátszás
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.")
A pcm formátum ideális streaminghez, mivel nem igényel dekódolást: a nyers bájtok azonnal lejátszhatók.
Késleltetés mérése
Az első bájt ideje (TTFB – Time to First Byte) a streaming teljesítményének kulcsmutatója:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""TTS streaming késleltetések mérése."""
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")
Aszinkron streaming
Szerveroldali alkalmazásokhoz használd az aszinkron klienst:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Aszinkron TTS streaming szerverek számára."""
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)
# Itt küldenéd el a darabot a kliensnek WebSocketen keresztül
yield chunk
# Használat egy FastAPI szerveren
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"
)
Előre feltöltött puffer
A megszakításmentes lejátszás biztosítása érdekében halmozz fel egy kis puffert a kezdés előtt:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Előre betöltendő darabok száma
):
"""TTS lejátszás előre feltöltött pufferrel."""
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
# Kezdeti puffer kiürítése
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Megmaradó darabok lejátszása
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integráció egy LLM + TTS folyamattal
Egy nem valós idejű hangalapú ügynöknél kombinálhatod az LLM streaminget a TTS streaminggel:
async def llm_to_tts_pipeline(user_message: str):
"""Folyamat: Streaming LLM → Valós idejű streaming TTS."""
# 1. fázis: LLM válasz felhalmozása mondatonként
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Csak a válaszszöveget kell kimondani
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Mondatvég észlelése
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# 2. fázis: Ezen mondat streamingje a TTS-be
stream_tts_to_speaker(sentence)
# Megmaradó puffer feldolgozása
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Főbb megállapítások
- A TTS streaming néhány száz milliszekundumra csökkenti a TTFB-t azáltal, hogy a generálás befejezése előtt elindítja a lejátszást
- A
pcmformátum optimális streaminghez: nem igényel dekódolást, közvetlenül lejátszható - Egy 2–3 darabból álló előre feltöltött puffer megakadályozza a szüneteket a lejátszás elején
- Az aszinkron kliens elengedhetetlen a több egyidejű kapcsolatot kezelő szerverek számára
- A streaming LLM és a streaming TTS kombinálása lehetővé teszi a gyors reagálású hangalapú ügynököt a Realtime API nélkül is