De responsaudio ontvangen en afspelen
Op deze pagina
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:
- Detecteer de onderbreking: het
speech_started-event komt binnen terwijl de audio wordt afgespeeld. - Stop de weergave: maak de audiowachtrij leeg en stop het geluid.
- Annuleer de respons: stuur
response.cancelzodat de server stopt met genereren. - 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