Pretakanje zvoka v realnem času
Na tej strani
Posodobitev 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli:
tts-1,tts-1-hdingpt-4o-mini-ttsbodo prenehali delovati 6. januarja 2027 (naslednik:gpt-realtime-2.1-mini, ki ga vodnik za OpenAI TTS navaja kot nepodprt s strani/v1/audio/speech: selitev sinteze glasu prehaja na Realtime API);gpt-realtime,gpt-4o-realtimein stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribein/v1/audio/translations26. februarja 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Za polnodupleksni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026. Posodobljeno 3. novembra 2026: Cevovod LLM → TTS je prej obdelal vsak dogodek s poljemdelta, vključno z argumenti klicev funkcij ali povzetki razmišljanja; zdaj strogo filtrira leresponse.output_text.delta, torej dejansko besedilo odgovora.
Pretakanje zvoka v realnem času
Pri glasovnem agentu čakanje, da se celotna zvočna datoteka ustvari pred začetkom predvajanja, povzroča nesprejemljivo zakasnitev. Pretakanje TTS ti omogoča, da začneš s predvajanjem takoj, ko prispejo prvi bajti, s čimer skrajšaš čas do prvega odgovora na nekaj sto milisekund.
Pretakanje s TTS API-jem
TTS API samodejno podpira pretakanje. Namesto čakanja na celotno datoteko prejmeš zvok v kosih:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Ustvari in predvajaj zvok v načinu pretakanja."""
# Inicializiraj zvočni predvajalnik
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Ustvari odziv s pretakanjem
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Surovi PCM za neposredno predvajanje
) as response:
# Beri in predvajaj kos za kosom
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.")
Zapis pcm je idealen za pretakanje, ker ne zahteva dekodiranja: surovi bajti so takoj pripravljeni za predvajanje.
Merjenje zakasnitve
Čas do prvega bajta (TTFB) je ključni kazalnik uspešnosti pretakanja:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Izmeri zakasnitve pretakanja 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")
Asinhrono pretakanje
Za strežniške aplikacije uporabi asinhronega odjemalca:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asinhrono pretakanje TTS za strežnike."""
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 bi kos poslali odjemalcu prek WebSocket-a
yield chunk
# Uporaba v strežniku 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"
)
Predpolnitev medpomnilnika
Za zagotovitev gladkega predvajanja brez presledkov najprej zberi majhen medpomnilnik:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Število kosov za prednalaganje
):
"""Predvajanje TTS s predpolnitvenim medpomnilnikom."""
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
# Izprazni začetni medpomnilnik
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Predvajaj preostale kose
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integracija s cevovodom LLM + TTS
Pri glasovnem agentu, ki ne uporablja Realtime API-ja, lahko združiš pretakanje LLM s pretakanjem TTS:
async def llm_to_tts_pipeline(user_message: str):
"""Cevovod: Pretakanje LLM → Pretakanje TTS v realnem času."""
# Faza 1: Zbiranje odgovora LLM po stavkih
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Izgovoriti je treba le besedilo odgovora
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Zaznaj konec stavka
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Faza 2: Pretakaj ta stavek v TTS
stream_tts_to_speaker(sentence)
# Obdelaj preostali medpomnilnik
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Ključne ugotovitve
- Pretakanje TTS skrajša TTFB na nekaj sto milisekund, saj se predvajanje začne, preden se generiranje konča
- Zapis
pcmje optimalen za pretakanje: ni potrebnega dekodiranja, omogoča neposredno predvajanje - Predpolnitveni medpomnilnik 2–3 kosov prepreči presledke na začetku predvajanja
- Asinhroni odjemalec je nujen za strežnike, ki upravljajo več sočasnih povezav
- Združevanje pretakanja LLM in pretakanja TTS omogoča odziven glasovni agent brez uporabe Realtime API-ja