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

Wysyłanie dźwięku za pomocą input_audio_buffer.append

Lekcja 7 z 16 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Strumieniowanie dźwięku do serwera
  2. Struktura zdarzenia
  3. Przechwytywanie dźwięku w przeglądarce
  4. Przechwytywanie dźwięku w Pythonie
  5. Rozmiar fragmentu i częstotliwość wysyłki
  6. Tłumienie echa
  7. Kluczowe wnioski

Strumieniowanie dźwięku do serwera

Gdy sesja zostanie skonfigurowana, możesz rozpocząć strumieniowanie dźwięku do serwera. Zdarzenie input_audio_buffer.append przesyła fragmenty dźwięku zakodowane w formacie base64.

Struktura zdarzenia

{
  "type": "input_audio_buffer.append",
  "audio": "SGVsbG8gV29ybGQ..."
}

Pole audio zawiera surowe dane dźwiękowe zakodowane w formacie base64. Ich format musi być zgodny z tym skonfigurowanym w session.update (domyślnie jest to 16-bitowe PCM little-endian przy częstotliwości 24000 Hz).

Przechwytywanie dźwięku w przeglądarce

Interfejs Web Audio API w przeglądarce pozwala na przechwytywanie sygnału z mikrofonu i wysyłanie danych w czasie rzeczywistym:

async function startCapture(ws) {
  const stream = await navigator.mediaDevices.getUserMedia({
    audio: {
      sampleRate: 24000,
      channelCount: 1,
      echoCancellation: true,
      noiseSuppression: true
    }
  });

  const audioContext = new AudioContext({ sampleRate: 24000 });
  const source = audioContext.createMediaStreamSource(stream);
  const processor = audioContext.createScriptProcessor(4096, 1, 1);

  processor.onaudioprocess = (event) => {
    const inputData = event.inputBuffer.getChannelData(0);
    const pcm16 = float32ToPCM16(inputData);
    const base64 = arrayBufferToBase64(pcm16.buffer);

    ws.send(JSON.stringify({
      type: "input_audio_buffer.append",
      audio: base64
    }));
  };

  source.connect(processor);
  processor.connect(audioContext.destination);
}

function float32ToPCM16(float32Array) {
  const pcm16 = new Int16Array(float32Array.length);
  for (let i = 0; i < float32Array.length; i++) {
    const s = Math.max(-1, Math.min(1, float32Array[i]));
    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
  }
  return pcm16;
}

function arrayBufferToBase64(buffer) {
  const bytes = new Uint8Array(buffer);
  let binary = "";
  for (let i = 0; i < bytes.byteLength; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  return btoa(binary);
}

Przechwytywanie dźwięku w Pythonie

Dzięki bibliotece pyaudio możesz przechwycić sygnał z mikrofonu i wysyłać go fragmentami:

import pyaudio
import base64
import json

RATE = 24000
CHUNK = 4096
FORMAT = pyaudio.paInt16
CHANNELS = 1

p = pyaudio.PyAudio()
stream = p.open(
    format=FORMAT,
    channels=CHANNELS,
    rate=RATE,
    input=True,
    frames_per_buffer=CHUNK
)

async def send_audio(ws):
    while True:
        data = stream.read(CHUNK, exception_on_overflow=False)
        audio_b64 = base64.b64encode(data).decode("utf-8")
        await ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": audio_b64
        }))

Rozmiar fragmentu i częstotliwość wysyłki

Rozmiar fragmentu wpływa na opóźnienia i wydajność:

  • Małe fragmenty (1024 próbki / ~42 ms): minimalne opóźnienie, ale większa liczba komunikatów WebSocket
  • Średnie fragmenty (4096 próbek / ~170 ms): dobry kompromis
  • Duże fragmenty (8192 próbki / ~341 ms): mniej komunikatów, ale zauważalne opóźnienie

Aby rozmowa brzmiała naturalnie, wysyłaj fragment co 100 do 200 ms. Moduł VAD serwera zbiera dane w wewnętrznym buforze i przetwarza je w sposób ciągły.

Tłumienie echa

Jeśli Twoja aplikacja odtwarza dźwięk odpowiedzi przez głośniki, gdy mikrofon jest aktywny, konieczne jest tłumienie echa. Bez niego agent usłyszy własny głos, co może doprowadzić do pętli rozmowy z samym sobą.

Masz następujące opcje:

  • Użyj opcji echoCancellation i noiseSuppression dostępnych w Web Audio API
  • Wycisz mikrofon, gdy agent mówi
  • Użyj zestawu słuchawkowego, aby odizolować wejście od wyjścia

Kluczowe wnioski

  • input_audio_buffer.append służy do wysyłania fragmentów dźwięku zakodowanych w formacie base64
  • Format danych musi być zgodny z konfiguracją sesji (domyślnie 16-bitowe PCM)
  • Wysyłaj fragment co 100–200 ms, aby zachować równowagę między opóźnieniem a wydajnością
  • Przechwytywanie dźwięku w przeglądarce wykorzystuje Web Audio API z konwersją Float32 na PCM16
  • Zadbaj o tłumienie echa, aby uniknąć pętli audio