Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Audio mit input_audio_buffer.append senden

Lektion 7 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Audio an den Server streamen
  2. Ereignisstruktur
  3. Audio im Browser erfassen
  4. Audio in Python erfassen
  5. Blockgröße und Frequenz
  6. Echounterdrückung
  7. Kernaussagen

Audio an den Server streamen

Sobald die Sitzung konfiguriert ist, können Sie Audio an den Server streamen. Das Ereignis input_audio_buffer.append sendet Audio-Blöcke, die in Base64 kodiert sind.

Ereignisstruktur

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

Das Feld audio enthält Rohaudiodaten, die in Base64 kodiert sind. Das Format muss dem übereinstimmen, das in session.update konfiguriert wurde (standardmäßig 16-Bit Little-Endian PCM bei 24.000 Hz).

Audio im Browser erfassen

Die Web Audio API des Browsers ermöglicht es, das Mikrofon aufzuzeichnen und die Daten in Echtzeit zu senden:

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 in Python erfassen

Mit der Bibliothek pyaudio können Sie das Mikrofon erfassen und die Blöcke senden:

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

Blockgröße und Frequenz

Die Blockgröße beeinflusst die Latenz und die Leistung:

  • Kleine Blöcke (1024 Abtastwerte / ~42 ms): minimale Latenz, aber mehr WebSocket-Nachrichten
  • Mittlere Blöcke (4096 Abtastwerte / ~170 ms): ein guter Kompromiss
  • Große Blöcke (8192 Abtastwerte / ~341 ms): weniger Nachrichten, aber spürbare Latenz

Für ein natürliches Gespräch senden Sie einen Block alle 100 bis 200 ms. Der VAD des Servers sammelt die Daten in einem internen Puffer und verarbeitet sie kontinuierlich.

Echounterdrückung

Wenn Ihre App die Antwort-Audio über Lautsprecher abspielt, während das Mikrofon aktiv ist, benötigen Sie eine Echounterdrückung. Ohne diese würde der Agent seine eigene Stimme hören und könnte in einem Gesprächsloop mit sich selbst enden.

Ihre Optionen:

  • Nutzen Sie die Optionen echoCancellation und noiseSuppression der Web Audio API
  • Stummschalten Sie das Mikrofon, während der Agent spricht
  • Verwenden Sie ein Headset, um Eingabe und Ausgabe zu isolieren

Kernaussagen

  • input_audio_buffer.append sendet Audio-Blöcke, die in Base64 kodiert sind
  • Das Datenformat muss der Sitzungskonfiguration entsprechen (standardmäßig 16-Bit PCM)
  • Senden Sie einen Block alle 100 bis 200 ms für ein gutes Gleichgewicht zwischen Latenz und Leistung
  • Die Audio-Erfassung im Browser verwendet die Web Audio API mit einer Umwandlung von Float32 zu PCM16
  • Behandeln Sie die Echounterdrückung, um Audio-Loops zu vermeiden