Strömning av ljud i båda riktningar
På denna sida
Uppdaterat 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsslutar fungera den 6 januari 2027 (ersättaren anges somgpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migreringen av talgenerering flyttas till Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full-duplex-röst har GPT-Live 1 funnits tillgänglig i API:t sedan den 10 september 2026.
Strömning av ljud i båda riktningar
Strömning av ljud i båda riktningar är kärnan i Realtime API. Du skickar kontinuerligt ljudbitar från mikrofonen, och modellen returnerar kontinuerligt svarsbitar i ljudformat. Dessa två strömmar är oberoende och kan köras samtidigt – vilket är det som gör samtalet naturligt.
Ljudformatet PCM16
Realtime API använder formatet 24 kHz mono 16-bitars PCM. Detta är ett rått, okomprimerat format: varje sample är ett 16-bitars signerat heltal. Valet prioriterar låg latens framför bandbreddseffektivitet.
Ljudbitar skickas Base64-kodade inom JSON-händelser. Varje bit representerar vanligtvis 20 till 100 ms ljud.
Skicka ljud: Mikrofoninfångning
Så här fångar du mikrofonen och strömmar ljudet:
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):
"""Fånga mikrofonen och skicka bitar till Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Ljudvarning: {status}")
# Konvertera till int16 och lägg i kö
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Starta infångning
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofon aktiv — prata nu...")
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
}))
Ljudbufferten på serversidan
Bitar som skickas via input_audio_buffer.append ackumuleras i en buffert på servern. Denna buffert bearbetas på två sätt:
- Automatiskt VAD-läge (
server_vad): Servern upptäcker när du slutar prata och bekräftar (commits) bufferten automatiskt. - Manuellt läge: Du skickar explicit
input_audio_buffer.commitför att utlösa bearbetning.
# Bekräfta ljudbufferten manuellt
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Eller töm bufferten utan att bearbeta den
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Ta emot svarsljud
Ljudsvar anländer i bitar via händelserna response.output_audio.delta. Du måste avkoda och spela upp dem kontinuerligt:
import pyaudio
async def play_response_audio(ws):
"""Ta emot och spela upp svarsljud."""
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":
# Avkoda Base64-ljudbiten
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Ljudsvar avslutat")
elif event["type"] == "response.output_audio_transcript.delta":
# Texttranskribering av svaret
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Kompletta applikationen: Röstkonversation
Så här sätter du ihop infångning och uppspelning för en hel konversation:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Vänta på session.created
await ws.recv()
# Konfigurera sessionen
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"output_modalities": ["audio"],
"instructions": "Du är en röstassistent. Svara på engelska.",
"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
# Starta infångning och uppspelning parallellt
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Hantera samtidiga strömmar
Utmaningen med strömning i båda riktningar är att du skickar och tar emot samtidigt över samma WebSocket. asyncio.gather startar båda korutinerna parallellt, men de delar samma WebSocket-objekt. Biblioteket websockets hanterar denna samtidighet korrekt.
Viktiga punkter
- Ljud överförs som 24 kHz mono 16-bitars PCM, Base64-kodat i JSON-händelser
- Bitar är vanligtvis 20 till 100 ms ljud för en bra balans mellan latens och overhead
- Ljudbufferten på serversidan ackumulerar bitar fram till bekräftelse (automatiskt i VAD-läge)
- Uppspelning av svar sker bit för bit via
response.output_audio.delta asyncio.gathermöjliggör samtidig infångning och uppspelning över samma WebSocket