Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

De responsaudio ontvangen en afspelen

Les 11 van 16 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Streaming-afspeeling
  2. Architectuur van de audiospeler
  3. Koppeling met de WebSocket-events
  4. Omgaan met onderbrekingen
  5. Audiospeler in Python
  6. Het transcript naast de audio tonen
  7. Belangrijkste punten

Streaming-afspeeling

Wanneer de voice-agent een respons genereert, komt de audio binnen in base64-gecodeerde fragmenten (delta’s). Uw applicatie moet deze decoderen, in een wachtrij plaatsen en vloeiend afspelen, zodat de gebruiker één continue respons hoort zonder onderbrekingen.

Architectuur van de audiospeler

Het principe is eenvoudig: elke ontvangen audiodelta wordt gedecodeerd en aan een wachtrij toegevoegd. Een afspeelproces verbruikt deze wachtrij en stuurt de gegevens naar de audio-uitgang van het systeem:

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

  enqueue(pcm16ArrayBuffer) {
    // Convert PCM16 to Float32 for the Web Audio API
    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;
  }
}

Koppeling met de WebSocket-events

Hier ziet u hoe u de audiospeler koppelt aan de events van de 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 response complete");
      break;

    case "input_audio_buffer.speech_started":
      // The user interrupts the agent
      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;
}

Omgaan met onderbrekingen

In een natuurlijk gesprek kan de gebruiker de agent onderbreken door tijdens diens respons te spreken. Uw applicatie moet dit afhandelen:

  1. Detecteer de onderbreking: het speech_started-event komt binnen terwijl de audio wordt afgespeeld.
  2. Stop de weergave: maak de audiowachtrij leeg en stop het geluid.
  3. Annuleer de respons: stuur response.cancel zodat de server stopt met genereren.
  4. Luister: de gebruiker heeft het woord en de cyclus begint opnieuw.

Dit “barge-in”-mechanisme is essentieel voor een vloeiend gesprek. Zonder dit mechanisme zouden gebruikers moeten wachten tot de agent is uitgesproken voordat ze kunnen antwoorden.

Audiospeler in Python

Voor een Python-applicatie kunt u pyaudio gebruiken voor de weergave:

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

Het transcript naast de audio tonen

Tijdens het afspelen van de audio kunt u het responstranscript in realtime weergeven met behulp van de response.output_audio_transcript.delta-events. Gebruikers kunnen dan meelezen wat de agent zegt, wat helpt in lawaaierige omgevingen en de toegankelijkheid verbetert:

let currentTranscript = "";

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

Belangrijkste punten

  • Responsaudio komt binnen als base64-fragmenten via response.output_audio.delta
  • Gebruik een audiowachtrij om continue weergave zonder hiaten te garanderen
  • Handel onderbrekingen (barge-in) af door de weergave te stoppen en de respons te annuleren
  • Toon het transcript naast de audio om de toegankelijkheid te verbeteren
  • De Web Audio API van de browser vereist een conversie van base64 naar PCM16 en vervolgens naar Float32