Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Valós idejű audió streaming

12. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Valós idejű audió streaming
  2. Streaming a TTS API-val
  3. Késleltetés mérése
  4. Aszinkron streaming
  5. Előre feltöltött puffer
  6. Integráció egy LLM + TTS folyamattal
  7. Főbb megállapítások

Frissítés: 2026. november 2. — Audió modellek. A tanfolyam több modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts 2027. 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); a gpt-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); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations 2027. 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, amely delta mezőt tartalmazott, beleértve a függvényhívási argumentumokat vagy az érvelési összefoglalókat is; most már szigorúan csak a response.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 pcm formá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