Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Srautinis dvikryptis garso perdavimas

Paskaita 3 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Srautinis dvikryptis garso perdavimas
  2. PCM16 garso formatas
  3. Garso siuntimas: mikrofono fiksavimas
  4. Atsakymo garso gavimas
  5. Pilnas taikymas: balsinis pokalbis
  6. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę: tts-1, tts-1-hd ir gpt-4o-mini-tts nustos 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-realtime ir 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-transcribe ir /v1/audio/translations nustos 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.

24 kHz
Diskretizavimo dažnis
16 bit
Mėginio gylis
Mono
Vienas kanalas
48 KB/s
Žalio garso bitų sparta

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.gather leidžia vienu metu fiksuoti ir atkurti garso srautą ta pačia „WebSocket“ jungtimi