Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Bidirektsionaalne helivoogedus

Õppetund 3 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Bidirektsionaalne helivoogedus
  2. PCM16 helivorming
  3. Helide saatmine: mikrofoni hõivamine
  4. Vastuse heli vastuvõtmine
  5. Täielik rakendus: häälevestlus
  6. Peamised punktid

Uuendatud 2. novembril 2026 – Helimudelid. Mitmed selles kursuses käsitletud mudelid on aegunud: tts-1, tts-1-hd ja gpt-4o-mini-tts lõpetavad töö 6. jaanuaril 2027 (asendajaks on gpt-realtime-2.1-mini, mida OpenAI TTS juhend kirjeldab kui mittetoetatud teenuse /v1/audio/speech poolt: kõnesünteesi migratsioon viiakse üle Realtime API-le); gpt-realtime, gpt-4o-realtime ja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. veebruaril 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täisdupleksseks hääleks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.

Bidirektsionaalne helivoogedus

Bidirektsionaalne helivoogedus on Realtime API tuum. Sa saadad mikrofonist pidevalt helilõike ja mudel tagastab vastuseks pidevalt helilõike. Need kaks voogu on sõltumatud ja saavad töötada samaaegselt – just see teeb vestluse loomulikuks.

PCM16 helivorming

Realtime API kasutab 24 kHz mono 16-bitist PCM-vormingut. See on toore, tihendamata vorming: iga proov on 16-bitine märgiga täisarv. See valik eelistab madalat latentsust ribalaiuse efektiivsusele.

24 kHz
Diskreetimissagedus
16 bit
Proovi sügavus
Mono
Üks kanal
48 KB/s
Toore heli bitikiirus

Helilõigud saadetakse JSON-sündmuste sees Base64-kodeerituna. Iga lõik esindab tavaliselt 20–100 ms heli.

Helide saatmine: mikrofoni hõivamine

Siin on näide, kuidas mikrofonist heli hõivata ja voogedada:

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):
    """Hõiva mikrofon ja saada lõigud Realtime API-le."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio warning: {status}")
        # Teisenda int16-ks ja lisa järjekorda
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Käivita hõivamine
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofon aktiivne – räägi nüüd...")
        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
            }))

Serveripoolne helipuhver

Lõigud, mis saadetakse käsuga input_audio_buffer.append, kogunevad serveris puhvrisse. Seda puhvrit töödeldakse kahel viisil:

  • Automaatne VAD-režiim (server_vad): Server tuvastab, millal sa rääkimise lõpetad, ja fikseerib puhvri automaatselt.
  • Manuaalne režiim: Sa saadad sõnaselgelt käsuga input_audio_buffer.commit, et töötlemine käivitada.
# Fikseeri helipuhver manuaalselt
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Või tühjenda puhver ilma seda töötlemata
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Vastuse heli vastuvõtmine

Heli vastused saabuvad lõikudena sündmuste response.output_audio.delta kaudu. Sa pead need dekodeerima ja pidevalt esitama:

import pyaudio

async def play_response_audio(ws):
    """Võta vastu ja esita vastuse heli."""
    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":
                # Dekodeeri Base64 helilõik
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Heli vastus lõppenud")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Vastuse tekstiline transkriptsioon
                print(event["delta"], end="", flush=True)

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

Täielik rakendus: häälevestlus

Siin on näide, kuidas ühendada hõivamine ja taasesitus täielikuks vestluseks:

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

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

        # Seadista seanss
        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

        # Käivita hõivamine ja taasesitus paralleelselt
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Samaaegsete voogude haldamine

Bidirektsionaalse voogeduse väljakutse seisneb selles, et saadad ja võtad vastu samaaegselt sama WebSocketi kaudu. asyncio.gather käivitab mõlemad korutiinid paralleelselt, kuid need jagavad sama WebSocketi objekti. Teek websockets käsitleb seda samaaegsust korrektselt.

Peamised punktid

  • Heli edastatakse 24 kHz mono 16-bitise PCM-ina, Base64-kodeerituna JSON-sündmustes
  • Lõigud on tavaliselt 20–100 ms heli, et saavutada hea kompromiss latentsuse ja üldkulude vahel
  • Serveripoolne helipuhver kogub lõike kuni fikseerimiseni (VAD-režiimis automaatne)
  • Vastuse taasesitus toimub lõik-haaval sündmuse response.output_audio.delta kaudu
  • asyncio.gather võimaldab samaaegset hõivamist ja taasesitust samal WebSocketil