Strumieniowanie dźwięku w czasie rzeczywistym
Na tej stronie
Aktualizacja z 2 listopada 2026 — Modele audio. Kilka modeli omawianych w tym kursie zostało wycofanych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 r. (następca:gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy głosu przenosi się do Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio przestaną działać 20 stycznia 2027 r. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translationsprzestaną działać 26 lutego 2027 r. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). W przypadku komunikacji pełnodupleksowej (full-duplex), GPT-Live 1 jest dostępny w API od 10 września 2026 r. Zaktualizowano 3 listopada 2026 r.: Potok LLM → TTS wcześniej przetwarzał dowolne zdarzenie zawierające poledelta, w tym argumenty wywołań funkcji lub podsumowania rozumowania; obecnie filtruje on ściśle tylkoresponse.output_text.delta, czyli właściwy tekst odpowiedzi.
Strumieniowanie dźwięku w czasie rzeczywistym
W agencie głosowym oczekiwanie na wygenerowanie całego pliku audio przed rozpoczęciem odtwarzania wprowadza nieakceptowalne opóźnienia. Strumieniowanie TTS pozwala rozpocząć odtwarzanie natychmiast po otrzymaniu pierwszych bajtów, skracając czas do pierwszej odpowiedzi do kilkuset milisekund.
Strumieniowanie z API TTS
API TTS obsługuje strumieniowanie natywnie. Zamiast czekać na kompletny plik, otrzymujesz dźwięk w fragmentach:
from openai import OpenAI
import pyaudio
client = OpenAI()
def stream_tts_to_speaker(text: str, voice: str = "alloy"):
"""Generuj i odtwarzaj audio w trybie strumieniowym."""
# Inicjalizacja odtwarzacza audio
pa = pyaudio.PyAudio()
player = pa.open(
format=pyaudio.paInt16,
channels=1,
rate=24000,
output=True
)
try:
# Utworzenie odpowiedzi strumieniowej
with client.audio.speech.with_streaming_response.create(
model="tts-1",
voice=voice,
input=text,
response_format="pcm" # Surowy PCM do bezpośredniego odtwarzania
) as response:
# Odczyt i odtwarzanie fragment po fragmencie
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.")
Format pcm jest idealny do strumieniowania, ponieważ nie wymaga dekodowania: surowe bajty są gotowe do natychmiastowego odtworzenia.
Pomiar opóźnień
Czas do pierwszego bajtu (TTFB – Time to First Byte) to kluczowa metryka wydajności strumieniowania:
import time
def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
"""Mierz opóźnienia strumieniowania 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")
Strumieniowanie asynchroniczne
W aplikacjach serwerowych użyj klienta asynchronicznego:
from openai import AsyncOpenAI
import asyncio
async_client = AsyncOpenAI()
async def stream_tts_async(text: str, voice: str = "alloy"):
"""Asynchroniczne strumieniowanie TTS dla serwerów."""
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)
# Tutaj wysłałbyś fragment do klienta przez WebSocket
yield chunk
# Użycie w serwerze 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"
)
Bufor wstępny
Aby zapewnić płynne odtwarzanie bez przerw, zgromadź niewielki bufor przed rozpoczęciem:
async def buffered_tts_playback(
text: str,
voice: str = "alloy",
buffer_size: int = 3 # Liczba fragmentów do wstępnego załadowania
):
"""Odtwarzanie TTS z buforem wstępnym."""
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
# Opróżnienie początkowego bufora
for buffered_chunk in buffer:
player.write(buffered_chunk)
buffer.clear()
elif playback_started:
player.write(chunk)
# Odtwórz pozostałe fragmenty
for remaining in buffer:
player.write(remaining)
finally:
player.stop_stream()
player.close()
pa.terminate()
Integracja z potokiem LLM + TTS
W agencie głosowym niekorzystającym z Realtime API możesz połączyć strumieniowanie LLM ze strumieniowaniem TTS:
async def llm_to_tts_pipeline(user_message: str):
"""Potok: Strumieniowanie LLM → Strumieniowanie TTS w czasie rzeczywistym."""
# Faza 1: Akumulacja odpowiedzi LLM zdanie po zdaniu
sentence_buffer = ""
stream = client.responses.create(
model="gpt-5.6-luna",
input=[{"role": "user", "content": user_message}],
stream=True
)
for event in stream:
# Wymawiany powinien być tylko tekst odpowiedzi
if event.type == "response.output_text.delta":
sentence_buffer += event.delta
# Wykrycie końca zdania
if sentence_buffer.rstrip().endswith((".", "!", "?")):
sentence = sentence_buffer.strip()
sentence_buffer = ""
# Faza 2: Strumieniuj to zdanie do TTS
stream_tts_to_speaker(sentence)
# Przetwórz pozostałą część bufora
if sentence_buffer.strip():
stream_tts_to_speaker(sentence_buffer.strip())
Kluczowe wnioski
- Strumieniowanie TTS skraca czas TTFB do kilkuset milisekund, rozpoczynając odtwarzanie przed zakończeniem generowania
- Format
pcmjest optymalny do strumieniowania: nie wymaga dekodowania, umożliwia bezpośrednie odtwarzanie - Bufor wstępny składający się z 2–3 fragmentów zapobiega przerwom na początku odtwarzania
- Klient asynchroniczny jest niezbędny w serwerach obsługujących wiele jednoczesnych połączeń
- Połączenie strumieniowania LLM i strumieniowania TTS pozwala stworzyć responsywnego agenta głosowego bez użycia Realtime API