Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Straumēšana abos virzienos

Nodarbība 3 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Straumēšana abos virzienos
  2. PCM16 audio formāts
  3. Audio nosūtīšana: Mikrofona uztveršana
  4. Atbildes audio saņemšana
  5. Pilna lietotne: Balss saruna
  6. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši: tts-1, tts-1-hd un gpt-4o-mini-tts pārtrauks darboties 2027. gada 6. janvārī (norādītā aizstājēja ir gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata definē kā ** neatbalstītu ar /v1/audio/speech**: runas sintēzes migrācija pāriet uz Realtime API); gpt-realtime, gpt-4o-realtime un vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe un /v1/audio/translations — 2027. gada 26. februārī (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilndupleksa balss funkcionalitātei GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.

Straumēšana abos virzienos

Straumēšana abos virzienos ir Realtime API pamatā. Tu nepārtraukti nosūti audio fragmentus no mikrofona, un modelis nepārtraukti atgriež atbildes audio fragmentus. Šīs divas plūsmas ir neatkarīgas un var darboties vienlaicīgi — tieši tas padara sarunu dabisku.

PCM16 audio formāts

Realtime API izmanto 24 kHz mono 16 bitu PCM formātu. Tas ir neapstrādāts, nesaspiests formāts: katrs paraugs ir 16 bitu zīmēts vesels skaitlis. Šī izvēle prioritāri nodrošina zemu latentumu, nevis joslas platuma efektivitāti.

24 kHz
Diskretizācijas frekvence
16 bit
Parauga dziļums
Mono
Viens kanāls
48 KB/s
Neapstrādāta audio bitu ātrums

Audio fragmenti tiek nosūtīti Base64 kodējumā JSON notikumu ietvaros. Katrs fragments parasti atbilst 20 līdz 100 ms ilgam audio ierakstam.

Audio nosūtīšana: Mikrofona uztveršana

Lūk, kā uztvert mikrofonu un straumēt audio:

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):
    """Uztver mikrofonu un nosūta fragmentus uz Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio brīdinājums: {status}")
        # Konvertē uz int16 un ievieto rindā
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Sāk uztveršanu
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofons aktīvs — runā tagad...")
        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
            }))

Audio buferis servera pusē

Fragmenti, kas nosūtīti, izmantojot input_audio_buffer.append, uzkrājas buferī servera pusē. Šo buferi apstrādā divos veidos:

  • Automātiskais VAD režīms (server_vad): Serveris nosaka, kad tu esi beidzis runāt, un automātiski fiksē buferi.
  • Manuālais režīms: Tu eksplicīti nosūti input_audio_buffer.commit, lai iniciētu apstrādi.
# Manuāli fiksē audio buferi
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Vai notīra buferi, to neapstrādājot
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Atbildes audio saņemšana

Atbildes audio ierodas fragmentos, izmantojot response.output_audio.delta notikumus. Tie ir jāatšifrē un jāatskaņo nepārtraukti:

import pyaudio

async def play_response_audio(ws):
    """Saņem un atskaņo atbildes 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":
                # Atšifrē Base64 audio fragmentu
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Audio atbilde pabeigta")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Atbildes teksta transkripcija
                print(event["delta"], end="", flush=True)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Pilna lietotne: Balss saruna

Lūk, kā apvienot uztveršanu un atskaņošanu pilnvērtīgai sarunai:

async def conversation_vocale():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Gaida session.created
        await ws.recv()

        # Konfigurē sesiju
        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

        # Palaiž uztveršanu un atskaņošanu paralēli
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Vienlaicīgu plūsmu pārvaldība

Izaicinājums, strādājot ar straumēšanu abos virzienos, ir tas, ka tu vienlaicīgi sūti un saņem datus vienā un tajā pašā WebSocket savienojumā. asyncio.gather palaiž abas korutīnas paralēli, taču tās koplieto vienu un to pašu WebSocket objektu. Bibliotēka websockets šo vienlaicīgumu apstrādā korekti.

Galvenās atziņas

  • Audio tiek pārraidīts kā 24 kHz mono 16 bitu PCM, kodēts Base64 formātā JSON notikumos
  • Fragmenti parasti ir 20 līdz 100 ms ilgi, lai nodrošinātu labu līdzsvaru starp latentumu un pieskaitāmajām izmaksām
  • Servera puses audio buferis uzkrāj fragmentus līdz fiksēšanai (automātiski VAD režīmā)
  • Atbildes atskaņošana notiek pa fragmentiem, izmantojot response.output_audio.delta
  • asyncio.gather ļauj vienlaicīgi uztvert un atskaņot audio vienā WebSocket savienojumā