Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Audio verzenden met input_audio_buffer.append

Les 7 van 16 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Audio streamen naar de server
  2. Structuur van de gebeurtenis
  3. Audio vastleggen in de browser
  4. Audio vastleggen in Python
  5. Chunk-grootte en frequentie
  6. Echocancellatie
  7. Belangrijkste punten

Audio streamen naar de server

Zodra de sessie is geconfigureerd, kunt u beginnen met het streamen van audio naar de server. De gebeurtenis input_audio_buffer.append verzendt audiochunks die zijn gecodeerd in base64.

Structuur van de gebeurtenis

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

Het veld audio bevat ruwe audiogegevens die zijn gecodeerd in base64. De indeling moet overeenkomen met de configuratie in session.update (standaard 16-bit little-endian PCM op 24000 Hz).

Audio vastleggen in de browser

Met de Web Audio API van de browser kunt u de microfoon vastleggen en de gegevens in realtime verzenden:

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);
}

Audio vastleggen in Python

Met de bibliotheek pyaudio kunt u de microfoon vastleggen en de chunks verzenden:

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
        }))

Chunk-grootte en frequentie

De grootte van de chunks heeft invloed op de latentie en de prestaties:

  • Kleine chunks (1024 samples / ~42 ms): minimale latentie, maar meer WebSocket-berichten
  • Middelgrote chunks (4096 samples / ~170 ms): een goed compromis
  • Grote chunks (8192 samples / ~341 ms): minder berichten, maar merkbare latentie

Voor een natuurlijk gesprek verzendt u best om de 100 tot 200 ms een chunk. De VAD van de server verzamelt de gegevens in een interne buffer en verwerkt deze continu.

Echocancellatie

Als uw applicatie de responsaudio via luidsprekers afspeelt terwijl de microfoon actief is, heeft u echocancellatie nodig. Zonder dit zou de agent zichzelf horen spreken en mogelijk in een conversatielus met zichzelf terecht komen.

Uw opties:

  • Gebruik de opties echoCancellation en noiseSuppression van de Web Audio API
  • Dempt u de microfoon terwijl de agent spreekt
  • Gebruik een headset om input en output van elkaar te isoleren

Belangrijkste punten

  • input_audio_buffer.append verzendt audiochunks die zijn gecodeerd in base64
  • De gegevensindeling moet overeenkomen met de sessieconfiguratie (standaard 16-bit PCM)
  • Verzend om de 100 tot 200 ms een chunk voor een goede balans tussen latentie en prestaties
  • Audio-vastlegging in de browser gebruikt de Web Audio API met een conversie van Float32 naar PCM16
  • Voorzie echocancellatie om audiolussen te voorkomen