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

Kétirányú audio streaming

3. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Kétirányú audio streaming
  2. PCM16 audió formátum
  3. Audió küldése: Mikrofon rögzítése
  4. Válasz audió fogadása
  5. Teljes alkalmazás: Hangalapú beszélgetés
  6. Főbb megállapítások

Frissítve: 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 (a javasolt utód a gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a /v1/audio/speech nem támogat: a beszédszintézis migrációja a Realtime API-ra helyeződik át); a gpt-realtime, gpt-4o-realtime és a legacy audió modellek 2027. január 20-án válnak elavulttá (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations endpointok 2027. február 26-án szűnnek meg (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). A teljes duplex hangalapú kommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.

Kétirányú audio streaming

A kétirányú audio streaming a Realtime API szíve-lelke. Folyamatosan küldesz audió darabkákat a mikrofonról, és a modell folyamatosan visszaadja a válasz audió darabkáit. Ez a két adatfolyam független, és egyszerre működhet – ettől lesz a beszélgetés természetes hatású.

PCM16 audió formátum

A Realtime API 24 kHz-es, mono, 16 bites PCM formátumot használ. Ez egy nyers, tömörítetlen formátum: minden minta egy 16 bites előjeles egész szám. Ez a választás a kis késleltetést helyezi előtérbe a sávszélesség-hatékonysággal szemben.

24 kHz
Mintavételezési frekvencia
16 bit
Mintamélység
Mono
Egy csatorna
48 KB/s
Nyers audió bitráta

Az audió darabkákat Base64-kódolással küldöd JSON eseményeken belül. Egy darabka jellemzően 20–100 ms hosszúságú audiót reprezentál.

Audió küldése: Mikrofon rögzítése

Így rögzítheted a mikrofont és streamelheted az audiót:

import asyncio
import sounddevice as sd
import numpy as np
import base64
import json

SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)

async def stream_microphone(ws):
    """Rögzíti a mikrofont és darabkákat küld a Realtime API-nak."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio warning: {status}")
        # Átalakítás int16-ra és sorba állítás
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Rögzítés indítása
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofon aktív — most beszélhetsz...")
        while True:
            pcm_data = await audio_queue.get()
            audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")

            await ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": audio_b64
            }))

A szerveroldali audió puffer

Az input_audio_buffer.append segítségével küldött darabkák felhalmozódnak egy szerveroldali pufferben. Ezt a puffert kétféleképpen dolgozza fel a rendszer:

  • Automatikus VAD mód (server_vad): A szerver érzékeli, amikor abbahagyod a beszédet, és automatikusan véglegesíti (commit) a puffert.
  • Kézi mód: Expliciten elküldöd az input_audio_buffer.commit parancsot a feldolgozás elindításához.
# Audió puffer kézi véglegesítése
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Vagy a puffer törlése feldolgozás nélkül
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Válasz audió fogadása

A válasz audió darabkákban érkezik meg a response.output_audio.delta eseményeken keresztül. Ezeket folyamatosan dekódolnod és le kell játszanod:

import pyaudio

async def play_response_audio(ws):
    """Fogadja és lejátsza a válasz audiót."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=SAMPLE_RATE,
        output=True,
        frames_per_buffer=CHUNK_SIZE
    )

    try:
        async for raw_message in ws:
            event = json.loads(raw_message)

            if event["type"] == "response.output_audio.delta":
                # Base64 audió darabka dekódolása
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Audió válasz befejeződött")

            elif event["type"] == "response.output_audio_transcript.delta":
                # A válasz szöveges átírása
                print(event["delta"], end="", flush=True)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Teljes alkalmazás: Hangalapú beszélgetés

Így állíthatod össze a rögzítést és a lejátszást egy teljes beszélgetéshez:

async def conversation_vocale():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Várakozás a session.created eseményre
        await ws.recv()

        # Munkamenet konfigurálása
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "You are a voice assistant. Respond in English.",
                "audio": {
                    "input": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 700
                        }
                    },
                    "output": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "voice": "marin"
                    }
                }
            }
        }))
        await ws.recv()  # session.updated

        # Rögzítés és lejátszás indítása párhuzamosan
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Egyidejű adatfolyamok kezelése

A kétirányú streaming kihívása, hogy ugyanazon a WebSocket kapcsolaton egyszerre küldesz és fogadsz adatot. Az asyncio.gather mindkét koroutint párhuzamosan indítja el, de ugyanazt a WebSocket objektumot használják. A websockets könyvtár helyesen kezeli ezt az egyidejűséget.

Főbb megállapítások

  • Az audiót 24 kHz-es, mono, 16 bites PCM formátumban továbbítjuk, JSON eseményekben Base64-kódolással
  • A darabkák jellemzően 20–100 ms hosszúságúak, ami jó kompromisszum a késleltetés és a túlterhelés között
  • A szerveroldali audió puffer felhalmozza a darabkákat a véglegesítésig (VAD módban ez automatikus)
  • A válasz lejátszása darabról darabra történik a response.output_audio.delta eseményeken keresztül
  • Az asyncio.gather lehetővé teszi a rögzítés és a lejátszás egyidejű végrehajtását ugyanazon a WebSocket kapcsolaton