Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Empfang und Wiedergabe der Antwort-Audio

Lektion 11 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Streaming-Wiedergabe
  2. Architektur des Audiowiedergabespiels
  3. Anbindung an WebSocket-Ereignisse
  4. Behandlung von Unterbrechungen
  5. Audiowiedergabe in Python
  6. Transkript parallel anzeigen
  7. Kernaussagen

Streaming-Wiedergabe

Wenn der Sprachagent eine Antwort generiert, wird das Audio in base64-kodierten Stücken (Deltas) empfangen. Ihre Anwendung muss diese decodieren, in einer Warteschlange anordnen und flüssig wiedergeben, sodass der Nutzer eine durchgehende Antwort hört, ohne Unterbrechungen.

Architektur des Audiowiedergabespiels

Das Prinzip ist einfach: Jeder empfangene Audio-Delta wird decodiert und einer Warteschlange hinzugefügt. Ein Wiedergabeprozess konsumiert die Warteschlange und sendet die Daten an die Audioausgabe des Systems:

class AudioStreamPlayer {
  constructor(sampleRate = 24000) {
    this.audioContext = new AudioContext({ sampleRate });
    this.queue = [];
    this.isPlaying = false;
    this.nextPlayTime = 0;
  }

  enqueue(pcm16ArrayBuffer) {
    // PCM16 in Float32 für die Web Audio API umwandeln
    const pcm16 = new Int16Array(pcm16ArrayBuffer);
    const float32 = new Float32Array(pcm16.length);
    for (let i = 0; i < pcm16.length; i++) {
      float32[i] = pcm16[i] / 32768.0;
    }

    const buffer = this.audioContext.createBuffer(
      1, float32.length, this.audioContext.sampleRate
    );
    buffer.getChannelData(0).set(float32);

    this.queue.push(buffer);
    if (!this.isPlaying) this.playNext();
  }

  playNext() {
    if (this.queue.length === 0) {
      this.isPlaying = false;
      return;
    }

    this.isPlaying = true;
    const buffer = this.queue.shift();
    const source = this.audioContext.createBufferSource();
    source.buffer = buffer;
    source.connect(this.audioContext.destination);

    const now = this.audioContext.currentTime;
    const startTime = Math.max(now, this.nextPlayTime);
    source.start(startTime);
    this.nextPlayTime = startTime + buffer.duration;

    source.onended = () => this.playNext();
  }

  stop() {
    this.queue = [];
    this.isPlaying = false;
    this.nextPlayTime = 0;
  }
}

Anbindung an WebSocket-Ereignisse

So verbinden Sie den Audiowiedergabeplayer mit den Ereignissen der API:

const player = new AudioStreamPlayer(24000);

ws.on("message", (data) => {
  const event = JSON.parse(data);

  switch (event.type) {
    case "response.output_audio.delta":
      const audioBytes = base64ToArrayBuffer(event.delta);
      player.enqueue(audioBytes);
      break;

    case "response.output_audio.done":
      console.log("Audio-Antwort abgeschlossen");
      break;

    case "input_audio_buffer.speech_started":
      // Der Nutzer unterbricht den Agenten
      player.stop();
      ws.send(JSON.stringify({ type: "response.cancel" }));
      break;
  }
});

function base64ToArrayBuffer(base64) {
  const binary = atob(base64);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i++) {
    bytes[i] = binary.charCodeAt(i);
  }
  return bytes.buffer;
}

Behandlung von Unterbrechungen

In einem natürlichen Gespräch kann der Nutzer den Agenten unterbrechen, indem er während der Antwort spricht. Ihre Anwendung muss dies handhaben:

  1. Unterbrechung erkennen: Das Ereignis speech_started geht ein, während Audio wiedergegeben wird
  2. Wiedergabe stoppen: Die Audio-Warteschlange leeren und den Ton abbrechen
  3. Antwort abbrechen: Senden Sie response.cancel, damit der Server die Generierung stoppt
  4. Zuhören: Der Nutzer hat das Wort, und der Zyklus beginnt von neuem

Dieser Mechanismus zum „Eindringen” (barge-in) ist für ein flüssiges Gespräch unerlässlich. Ohne ihn müsste der Nutzer warten, bis der Agent seine Rede beendet hat, bevor er antworten kann.

Audiowiedergabe in Python

Für eine Python-Anwendung können Sie pyaudio für die Wiedergabe verwenden:

import pyaudio
import base64
import asyncio
from collections import deque

class AudioPlayer:
    def __init__(self, rate=24000):
        self.p = pyaudio.PyAudio()
        self.stream = self.p.open(
            format=pyaudio.paInt16,
            channels=1,
            rate=rate,
            output=True
        )
        self.queue = deque()

    def enqueue(self, base64_audio):
        audio_bytes = base64.b64decode(base64_audio)
        self.queue.append(audio_bytes)

    def play_all(self):
        while self.queue:
            chunk = self.queue.popleft()
            self.stream.write(chunk)

    def stop(self):
        self.queue.clear()

Transkript parallel anzeigen

Während das Audio wiedergegeben wird, können Sie das Antwort-Transkript in Echtzeit mit den response.output_audio_transcript.delta-Ereignissen anzeigen. Nutzer können dann lesen, was der Agent sagt, was in lauten Umgebungen und für die Barrierefreiheit hilfreich ist:

let currentTranscript = "";

case "response.output_audio_transcript.delta":
  currentTranscript += event.delta;
  updateTranscriptDisplay(currentTranscript);
  break;

Kernaussagen

  • Antwort-Audio kommt als base64-Blöcke über response.output_audio.delta an
  • Verwenden Sie eine Audio-Warteschlange, um eine lückenlose Wiedergabe zu garantieren
  • Behandeln Sie Unterbrechungen (barge-in), indem Sie die Wiedergabe stoppen und die Antwort abbrechen
  • Zeigen Sie das Transkript parallel zum Audio an, um die Barrierefreiheit zu verbessern
  • Die Web Audio API des Browsers benötigt eine Umwandlung von base64 zu PCM16 und dann zu Float32