Srautinis dvikryptis garso perdavimas
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę:
tts-1,tts-1-hdirgpt-4o-mini-ttsnustos veikti 2027 m. sausio 6 d. (nurodytas pakaitalas –gpt-realtime-2.1-mini, kurio, kaip teigiama „OpenAI TTS“ gide, nepalaiko/v1/audio/speech: kalbos sintezės migracija perkeliama į „Realtime API“);gpt-realtime,gpt-4o-realtimeir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeir/v1/audio/translationsnustos veikti 2027 m. vasario 26 d. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Visadupleksiam balsui „GPT-Live 1“ API yra prieinamas nuo 2026 m. rugsėjo 10 d.
Srautinis dvikryptis garso perdavimas
Srautinis dvikryptis garso perdavimas yra „Realtime API“ pagrindas. Tu nuolat siunči garso fragmentus iš mikrofono, o modelis nuolat grąžina atsakymo garso fragmentus. Šie du srautai yra nepriklausomi ir gali veikti vienu metu – būtent todėl pokalbis skamba natūraliai.
PCM16 garso formatas
„Realtime API“ naudoja 24 kHz mono 16 bitų PCM formatą. Tai žalias, nesuglaudintas formatas: kiekvienas mėginys yra 16 bitų ženklintas sveikasis skaičius. Šis pasirinkimas teikia pirmenybę mažai delsai, o ne pralaidumo efektyvumui.
Garso fragmentai siunčiami Base64 koduote JSON įvykiuose. Kiekvienas fragmentas paprastai atitinka 20–100 ms garso įrašo.
Garso siuntimas: mikrofono fiksavimas
Štai kaip užfiksuoti mikrofoną ir perduoti garso srautą:
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):
"""Fiksuok mikrofoną ir siųsk fragmentus į Realtime API."""
loop = asyncio.get_event_loop()
audio_queue = asyncio.Queue()
def audio_callback(indata, frames, time_info, status):
if status:
print(f"Garso įspėjimas: {status}")
# Konvertuok į int16 ir įdėk į eilę
pcm_data = (indata[:, 0] * 32767).astype(np.int16)
loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)
# Pradėk fiksavimą
stream = sd.InputStream(
samplerate=SAMPLE_RATE,
channels=1,
dtype="float32",
blocksize=CHUNK_SIZE,
callback=audio_callback
)
with stream:
print("Mikrofonas aktyvus – kalbėk dabar...")
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
}))
Garso buferis serverio pusėje
Fragmentai, siunčiami naudojant input_audio_buffer.append, kaupiasi serverio buferio atmintyje. Šis buferis apdorojamas dviem būdais:
- Automatinis VAD režimas (
server_vad): Serveris aptinka, kai nustoji kalbėti, ir automatiškai įvykdo buferio fiksavimą. - Rankinis režimas: Tu aiškiai siunti
input_audio_buffer.commit, kad inicijuotum apdorojimą.
# Rankinis garso buferio fiksavimas
await ws.send(json.dumps({
"type": "input_audio_buffer.commit"
}))
# Arba išvalyk buferį neapdorodamas jo
await ws.send(json.dumps({
"type": "input_audio_buffer.clear"
}))
Atsakymo garso gavimas
Garso atsakymai atkeliauja fragmentais per response.output_audio.delta įvykius. Juos reikia nuolat dekoduoti ir groti:
import pyaudio
async def play_response_audio(ws):
"""Gauk ir grok atsakymo garsą."""
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":
# Dekoduok Base64 garso fragmentą
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event["type"] == "response.output_audio.done":
print("Garso atsakymas baigtas")
elif event["type"] == "response.output_audio_transcript.delta":
# Atsakymo tekstinė transkripcija
print(event["delta"], end="", flush=True)
finally:
player.stop_stream()
player.close()
pa.terminate()
Pilnas taikymas: balsinis pokalbis
Štai kaip sujungti fiksavimą ir atkūrimą visam pokalbiui:
async def conversation_vocale():
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
async with websockets.connect(URL, additional_headers=headers) as ws:
# Lauk session.created
await ws.recv()
# Konfigūruok sesiją
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
# Paleisk fiksavimą ir atkūrimą lygiagrečiai
await asyncio.gather(
stream_microphone(ws),
play_response_audio(ws)
)
asyncio.run(conversation_vocale())
Vienalaikių srautų valdymas
Dvikrypčio srautinio perdavimo iššūkis tas, kad siunti ir gauni duomenis vienu metu ta pačia „WebSocket“ jungtimi. asyncio.gather paleidžia abi korutinas lygiagrečiai, tačiau jos dalijasi tuo pačiu „WebSocket“ objektu. „websockets“ biblioteka teisingai tvarko šį vienalaikiškumą.
Svarbiausi punktai
- Garso duomenys perduodami 24 kHz mono 16 bitų PCM formatu, JSON įvykiuose koduoti Base64
- Fragmentai paprastai yra 20–100 ms garso įrašo, kad būtų pasiektas optimalus delsos ir pridėtinių išlaidų balansas
- Serverio pusės garso buferis kaupia fragmentus iki fiksavimo momento (VAD režimu tai vyksta automatiškai)
- Atsakymo atkūrimas vyksta fragmentas po fragmento per
response.output_audio.delta asyncio.gatherleidžia vienu metu fiksuoti ir atkurti garso srautą ta pačia „WebSocket“ jungtimi