Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Strujanje zvuka u oba smjera

Lekcija 3 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Strujanje zvuka u oba smjera
  2. PCM16 zvučni format
  3. Slanje zvuka: Snimanje mikrofona
  4. Primanje odgovornog zvuka
  5. Potpuna aplikacija: Glasovni razgovor
  6. Ključne točke

Ažurirano 2. studenoga 2026. — Zvučni modeli. Nekoliko modela u ovom tečaju je zastarjelo: tts-1, tts-1-hd i gpt-4o-mini-tts prestat će raditi 6. siječnja 2027. (navedena zamjena je gpt-realtime-2.1-mini, za koji OpenAI TTS vodič navodi da nije podržan putem /v1/audio/speech: migracija sinteze govora prelazi na Realtime API); gpt-realtime, gpt-4o-realtime i stariji zvučni modeli 20. siječnja 2027. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26. veljače 2027. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za full-duplex glas, GPT-Live 1 dostupan je u API-ju od 10. rujna 2026.

Strujanje zvuka u oba smjera

Strujanje zvuka u oba smjera srž je Realtime API-ja. Neprestano šalješ zvučne isječke s mikrofona, a model neprestano vraća odgovorne zvučne isječke. Ta su dva toka neovisna i mogu raditi istovremeno – što razgovoru daje prirodan osjećaj.

PCM16 zvučni format

Realtime API koristi format 24 kHz mono 16-bitni PCM. Riječ je o sirovom, nekompresiranom formatu: svaki uzorak je 16-bitni predznačeni cijeli broj. Ovaj izbor daje prednost niskoj latenciji nad učinkovitošću propusnosti.

24 kHz
Frekvencija uzorkovanja
16 bit
Dubina uzorka
Mono
Jedan kanal
48 KB/s
Brzina prijenosa sirovog zvuka

Zvučni isječki šalju se kodirani u Base64 unutar JSON događaja. Svaki isječak obično predstavlja 20 do 100 ms zvuka.

Slanje zvuka: Snimanje mikrofona

Evo kako snimiti mikrofon i strujiti zvuk:

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):
    """Snimi mikrofon i pošalji isječke Realtime API-ju."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio warning: {status}")
        # Pretvori u int16 i stavi u red
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

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

    with stream:
        print("Mikrofon aktivan — govori sada...")
        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
            }))

Zvučni međuspremnik na poslužitelju

Isječki poslani putem input_audio_buffer.append akumuliraju se u međuspremniku na poslužitelju. Taj se međuspremnik obrađuje na dva načina:

  • Automatski VAD način (server_vad): Poslužitelj detektira kada prestaneš govoriti i automatski potvrđuje međuspremnik.
  • Ručni način: Izričito šalješ input_audio_buffer.commit kako bi pokrenuo obradu.
# Ručno potvrdi zvučni međuspremnik
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Ili očisti međuspremnik bez obrade
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Primanje odgovornog zvuka

Zvučni odgovori stižu u isječcima putem događaja response.output_audio.delta. Moraš ih neprestano dekodirati i reproducirati:

import pyaudio

async def play_response_audio(ws):
    """Primi i reproduciraj odgovorni zvuk."""
    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":
                # Dekodiraj Base64 zvučni isječak
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Zvučni odgovor završen")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Tekstualni transkript odgovora
                print(event["delta"], end="", flush=True)

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

Potpuna aplikacija: Glasovni razgovor

Evo kako spojiti snimanje i reprodukciju za potpuni razgovor:

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

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

        # Konfiguriraj sesiju
        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

        # Pokreni snimanje i reprodukciju paralelno
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Upravljanje istovremenim tokovima

Izazov kod strujanja u oba smjera jest što istovremeno šalješ i primaš podatke na istom WebSocketu. asyncio.gather pokreće obje korutine paralelno, ali one dijele isti WebSocket objekt. Biblioteka websockets ispravno rukuje ovom istovremenošću.

Ključne točke

  • Zvuk se prenosi kao 24 kHz mono 16-bitni PCM, Base64-kodiran u JSON događajima
  • Isječki obično obuhvaćaju 20 do 100 ms zvuka za dobar kompromis između latencije i opterećenja
  • Zvučni međuspremnik na poslužitelju akumulira isječke do potvrde (automatski u VAD načinu)
  • Reprodukcija odgovora odvija se isječak po isječak putem response.output_audio.delta
  • asyncio.gather omogućuje istovremeno snimanje i reprodukciju na istom WebSocketu