Przejdź do głównej treści
Polski— Wybierz język
Menu

Strumieniowanie audio dwukierunkowe

Lekcja 3 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Strumieniowanie audio dwukierunkowe
  2. Format audio PCM16
  3. Wysyłanie audio: przechwytywanie z mikrofonu
  4. Odbieranie audio odpowiedzi
  5. Kompletna aplikacja: rozmowa głosowa
  6. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie zostało wycofanych: tts-1, tts-1-hd oraz gpt-4o-mini-tts przestaną działać 6 stycznia 2027 r. (zalecanym zamiennikiem jest gpt-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-realtime oraz 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-transcribe oraz /v1/audio/translations przestaną 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.

24 kHz
Częstotliwość próbkowania
16 bit
Głębia próbki
Mono
Pojedynczy kanał
48 KB/s
Surowa przepływność audio

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.gather umożliwia jednoczesne przechwytywanie i odtwarzanie na tym samym połączeniu WebSocket