Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Prenos zvoka v obeh smereh

Lekcija 3 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Prenos zvoka v obeh smereh
  2. Zvočni format PCM16
  3. Pošiljanje zvoka: Zajem mikrofona
  4. Sprejemanje odzivnega zvoka
  5. Celotna aplikacija: Glasovni pogovor
  6. Ključne ugotovitve

Posodobljeno 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli: tts-1, tts-1-hd in gpt-4o-mini-tts bodo prenehali delovati 6. januarja 2027 (navedena zamenjava je gpt-realtime-2.1-mini, ki pa po navodilih OpenAI za TTS ni podprta z /v1/audio/speech: selitev sinteze govora prehaja na Realtime API); gpt-realtime, gpt-4o-realtime in stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe in /v1/audio/translations 26. februarja 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za polno duplexni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026.

Prenos zvoka v obeh smereh

Prenos zvoka v obeh smereh je srce Realtime API-ja. Neprestano pošiljaš zvočne pakete z mikrofona, model pa ti neprestano vrača odzivne zvočne pakete. Ta dva toka sta neodvisna in lahko delujeta hkrati – prav to omogoča naraven potek pogovora.

Zvočni format PCM16

Realtime API uporablja format 24 kHz mono 16-bit PCM. To je surov, nekompresiran format: vsak vzorec je 16-bitno predznačeno celo število. Ta izbira daje prednost nizki zakasnitvi pred učinkovitostjo pasovne širine.

24 kHz
Frekvenca vzorčenja
16 bit
Globina vzorca
Mono
En kanal
48 KB/s
Surovi bitni pretok zvoka

Zvočni paketi se pošiljajo kodirani v Base64 znotraj dogodkov JSON. Vsak paket običajno predstavlja od 20 do 100 ms zvoka.

Pošiljanje zvoka: Zajem mikrofona

Tako zajameš zvok z mikrofona in ga pretakaš:

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):
    """Capture the microphone and send chunks to the Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio warning: {status}")
        # Convert to int16 and enqueue
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

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

    with stream:
        print("Microphone active — speak now...")
        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
            }))

Zvočni medpomnilnik na strežniku

Paketi, poslani prek input_audio_buffer.append, se kopičijo v medpomnilniku na strežniku. Ta medpomnilnik se obdela na dva načina:

  • Samodejni način VAD (server_vad): Strežnik zazna, ko prenehaš govoriti, in samodejno potrdi medpomnilnik.
  • Ročni način: Izrecno pošlješ input_audio_buffer.commit, da sprožiš obdelavo.
# Manually commit the audio buffer
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Or clear the buffer without processing it
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Sprejemanje odzivnega zvoka

Odzivni zvok prihaja v paketih prek dogodkov response.output_audio.delta. Te pakete moraš neprestano dekodirati in predvajati:

import pyaudio

async def play_response_audio(ws):
    """Receive and play response audio."""
    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":
                # Decode the Base64 audio chunk
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Audio response finished")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Text transcription of the response
                print(event["delta"], end="", flush=True)

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

Celotna aplikacija: Glasovni pogovor

Tako združiš zajem in predvajanje za celoten pogovor:

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

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

        # Configure the session
        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

        # Launch capture and playback in parallel
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Upravljanje sočasnih tokov

Izziv pri prenosu v obeh smereh je, da hkrati pošiljaš in prejemaš podatke prek istega vtiča WebSocket. asyncio.gather zažene obe korutini vzporedno, vendar si delita isti predmet WebSocket. Knjižnica websockets to sočasnost pravilno obravnava.

Ključne ugotovitve

  • Zvok se prenaša kot 24 kHz mono 16-bit PCM, kodiran v Base64 znotraj dogodkov JSON
  • Paketi običajno zajamejo od 20 do 100 ms zvoka za dobro razmerje med zakasnitvijo in splošnimi stroški
  • Zvočni medpomnilnik na strežniku kopiči pakete do potrditve (samodejno v načinu VAD)
  • Predvajanje odziva poteka paket za paketom prek response.output_audio.delta
  • asyncio.gather omogoča hkratni zajem in predvajanje prek istega vtiča WebSocket