Strujanje zvuka u oba smjera
Na ovoj stranici
Ažurirano 2. studenoga 2026. — Zvučni modeli. Nekoliko modela u ovom tečaju je zastarjelo:
tts-1,tts-1-hdigpt-4o-mini-ttsprestat će raditi 6. siječnja 2027. (navedena zamjena jegpt-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-realtimei 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-transcribei/v1/audio/translations26. 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.
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.commitkako 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.gatheromogućuje istovremeno snimanje i reprodukciju na istom WebSocketu