Prenos zvoka v obeh smereh
Na tej strani
Posodobljeno 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli:
tts-1,tts-1-hdingpt-4o-mini-ttsbodo prenehali delovati 6. januarja 2027 (navedena zamenjava jegpt-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-realtimein stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribein/v1/audio/translations26. 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.
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.gatheromogoča hkratni zajem in predvajanje prek istega vtiča WebSocket