Strumieniowanie audio dwukierunkowe
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 r. (zalecanym zamiennikiem jestgpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy mowy przechodzi do Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio przestaną działać 20 stycznia 2027 r. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translationsprzestaną działać 26 lutego 2027 r. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). W przypadku komunikacji głosowej full-duplex, GPT-Live 1 jest dostępny w API od 10 września 2026 r.
Strumieniowanie audio dwukierunkowe
Strumieniowanie audio dwukierunkowe stanowi sedno Realtime API. Nieprzerwanie wysyłasz fragmenty audio z mikrofonu, a model na bieżąco zwraca fragmenty audio odpowiedzi. Te dwa strumienie są niezależne i mogą działać jednocześnie – dzięki temu rozmowa brzmi naturalnie.
Format audio PCM16
Realtime API korzysta z formatu mono 16-bit PCM o częstotliwości 24 kHz. Jest to surowy, nieskompresowany format: każda próbka to 16-bitowa liczba całkowita ze znakiem. Wybór ten priorytetyzuje niskie opóźnienia kosztem efektywności przepustowości.
Fragmenty audio są wysyłane zakodowane w formacie Base64 wewnątrz zdarzeń JSON. Każdy fragment reprezentuje zazwyczaj od 20 do 100 ms audio.
Wysyłanie audio: przechwytywanie z mikrofonu
Oto sposób przechwytywania dźwięku z mikrofonu i jego strumieniowania:
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):
"""Przechwyć dźwięk z mikrofonu i wyślij fragmenty do 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}")
# Konwersja do int16 i dodanie do kolejki
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Rozpoczęcie przechwytywania
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofon aktywny — mów teraz...")
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
}))
Bufor audio po stronie serwera
Fragmenty wysyłane poprzez input_audio_buffer.append gromadzą się w buforze na serwerze. Bufor ten jest przetwarzany na dwa sposoby:
- Tryb automatyczny VAD (
server_vad): Serwer wykrywa moment, w którym przestajesz mówić, i automatycznie zatwierdza bufor. - Tryb ręczny: Jawnie wysyłasz
input_audio_buffer.commit, aby uruchomić przetwarzanie.
# Ręczne zatwierdzenie bufora audio
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Lub wyczyszczenie bufora bez jego przetwarzania
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Odbieranie audio odpowiedzi
Odpowiedzi audio przychodzą w fragmentach poprzez zdarzenia response.output_audio.delta. Musisz je na bieżąco dekodować i odtwarzać:
import pyaudio
async def play_response_audio(ws):
"""Odbierz i odtwórz audio odpowiedzi."""
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":
# Dekodowanie fragmentu audio Base64
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Odpowiedź audio zakończona")
elif event["type"] == "response.output_audio_transcript.delta":
# Transkrypcja tekstowa odpowiedzi
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Kompletna aplikacja: rozmowa głosowa
Oto sposób połączenia przechwytywania i odtwarzania w celu przeprowadzenia pełnej rozmowy:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Oczekiwanie na session.created
await ws.recv()
# Konfiguracja sesji
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
# Uruchomienie przechwytywania i odtwarzania równolegle
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Zarządzanie współbieżnymi strumieniami
Wyzwaniem w przypadku strumieniowania dwukierunkowego jest jednoczesne wysyłanie i odbieranie danych przez to samo połączenie WebSocket. asyncio.gather uruchamia obie korutyny równolegle, ale współdzielą one ten sam obiekt WebSocket. Biblioteka websockets poprawnie obsługuje tę współbieżność.
Kluczowe wnioski
- Audio jest przesyłane jako mono 16-bit PCM o częstotliwości 24 kHz, zakodowane w Base64 w zdarzeniach JSON
- Fragmenty mają zazwyczaj od 20 do 100 ms audio, co zapewnia dobry kompromis między opóźnieniem a narzutem
- Bufor audio po stronie serwera gromadzi fragmenty aż do zatwierdzenia (automatyczne w trybie VAD)
- Odtwarzanie odpowiedzi odbywa się fragment po fragmencie poprzez
response.output_audio.delta asyncio.gatherumożliwia jednoczesne przechwytywanie i odtwarzanie na tym samym połączeniu WebSocket