Przejdź do głównej treści
Polski— Wybierz język
Menu

Strumieniowanie dźwięku w czasie rzeczywistym

Lekcja 12 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Strumieniowanie dźwięku w czasie rzeczywistym
  2. Strumieniowanie z API TTS
  3. Pomiar opóźnień
  4. Strumieniowanie asynchroniczne
  5. Bufor wstępny
  6. Integracja z potokiem LLM + TTS
  7. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 — Modele audio. Kilka modeli omawianych w tym kursie zostało wycofanych: tts-1, tts-1-hd oraz gpt-4o-mini-tts przestaną 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-realtime oraz 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-transcribe oraz /v1/audio/translations przestaną 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 pole delta, w tym argumenty wywołań funkcji lub podsumowania rozumowania; obecnie filtruje on ściśle tylko response.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 pcm jest 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