Salt la conținutul principal
Română— Alege o limbă
Meniu

Flux audio bidirecțional

Lecția 3 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Flux audio bidirecțional
  2. Format audio PCM16
  3. Trimiterea audio: Captarea microfonului
  4. Recepcionarea audio de răspuns
  5. Aplicație completă: Conversație vocală
  6. Puncte cheie

Actualizat la 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor înceta să funcționeze la 6 ianuarie 2027 (înlocuitorul indicat este gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de /v1/audio/speech: migrarea sintezei vocale se mută către Realtime API); gpt-realtime, gpt-4o-realtime și modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe și /v1/audio/translations la 26 februarie 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.

Flux audio bidirecțional

Fluxul audio bidirecțional reprezintă nucleul Realtime API. Trimiteți continuu fragmente audio de la microfon, iar modelul returnează continuu fragmente audio de răspuns. Aceste două fluxuri sunt independente și pot opera simultan – ceea ce conferă conversației un caracter natural.

Format audio PCM16

Realtime API utilizează formatul PCM mono pe 16 biți la 24 kHz. Acesta este un format brut, necomprimat: fiecare eșantion este un întreg semnat pe 16 biți. Această alegere prioritizează latența scăzută în detrimentul eficienței lățimii de bandă.

24 kHz
Frecvență de eșantionare
16 bit
Adâncime eșantion
Mono
Canal unic
48 KB/s
Rată brută audio

Fragmentele audio sunt trimise codificate Base64 în cadrul evenimentelor JSON. Fiecare fragment reprezintă, de obicei, între 20 și 100 ms de audio.

Trimiterea audio: Captarea microfonului

Iată cum să capturați microfonul și să transmiteți fluxul audio:

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):
    """Capturează microfonul și trimite fragmente către Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Avertisment audio: {status}")
        # Convertire în int16 și adăugare în coadă
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Start captare
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Microfon activ — vorbiți acum...")
        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
            }))

Bufferul audio lato-server

Fragmentele trimise prin input_audio_buffer.append se acumulează într-un buffer pe server. Acest buffer este procesat în două moduri:

  • Mod VAD automat (server_vad): Serverul detectează când încetați să vorbiți și validează automat bufferul.
  • Mod manual: Trimiteți explicit input_audio_buffer.commit pentru a declanșa procesarea.
# Validare manuală a bufferului audio
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Sau golire buffer fără procesare
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Recepcionarea audio de răspuns

Răspunsurile audio sosesc fragmentat prin evenimente response.output_audio.delta. Trebuie să le decodați și să le redați continuu:

import pyaudio

async def play_response_audio(ws):
    """Recepționează și redă audio de răspuns."""
    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":
                # Decodare fragment audio Base64
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Răspuns audio terminat")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Transcriere text a răspunsului
                print(event["delta"], end="", flush=True)

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

Aplicație completă: Conversație vocală

Iată cum să asamblați captarea și redarea pentru o conversație completă:

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

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Așteptare session.created
        await ws.recv()

        # Configurare sesiune
        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

        # Lansare captare și redare în paralel
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Gestionarea fluxurilor concurente

Provocarea fluxului bidirecțional constă în trimiterea și recepționarea simultană pe același WebSocket. asyncio.gather lansează ambele coroutine în paralel, dar acestea partajează același obiect WebSocket. Biblioteca websockets gestionează corect această concurență.

Puncte cheie

  • Audio este transmis ca PCM mono pe 16 biți la 24 kHz, codificat Base64 în evenimente JSON
  • Fragmentele au de obicei 20–100 ms de audio pentru un compromis optim latență/suprasarcină
  • Bufferul audio lato-server acumulează fragmente până la validare (automat în mod VAD)
  • Redarea răspunsului se face fragment cu fragment prin response.output_audio.delta
  • asyncio.gather permite captarea și redarea simultane pe același WebSocket