Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Ta emot och spela upp ljudsvaret

Lektion 11 av 16 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Strömmande uppspelning
  2. Arkitektur för ljudspelare
  3. Koppla till WebSocket-händelser
  4. Hantera avbrott
  5. Ljudspelare i Python
  6. Visa transkriptionen parallellt
  7. Viktiga punkter

Strömmande uppspelning

När röstagenten genererar ett svar ankommer ljudet i base64-kodade bitar (deltan). Din app måste avkoda dem, köa dem och spela upp dem smidigt så att användaren hör ett sammanhängande svar utan avbrott.

Arkitektur för ljudspelare

Principen är enkel: varje ljuddelta du tar emot avkodas och läggs till i en kö. En uppspelningsprocess konsumerar kön och skickar datan till systemets ljudutgång:

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

Koppla till WebSocket-händelser

Så här kopplar du ljudspelaren till API:ts händelser:

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

Hantera avbrott

I ett naturligt samtal kan användaren avbryta agenten genom att prata över dess svar. Din app måste hantera detta:

  1. Upptäck avbrottet: händelsen speech_started ankommer medan ljudet spelas upp.
  2. Stoppa uppspelningen: töm ljudkön och stoppa ljudet.
  3. Avbryt svaret: skicka response.cancel så att servern slutar generera.
  4. Lyssna: användaren har ordet och cykeln startar om.

Denna “barge-in”-mekanism är avgörande för ett flytande samtal. Utan den skulle användarna behöva vänta på att agenten slutar tala innan de kan svara.

Ljudspelare i Python

För en Python-app kan du använda pyaudio för uppspelning:

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

Visa transkriptionen parallellt

Medan ljudet spelas upp kan du visa svarstranskriptionen i realtid med händelserna response.output_audio_transcript.delta. Användare kan då läsa vad agenten säger, vilket hjälper i bullriga miljöer och för tillgänglighet:

let currentTranscript = "";

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

Viktiga punkter

  • Svarsljud ankommer som base64-bitar via response.output_audio.delta
  • Använd en ljudkö för att garantera kontinuerlig uppspelning utan glapp
  • Hantera avbrott (barge-in) genom att stoppa uppspelningen och avbryta svaret
  • Visa transkriptionen parallellt med ljudet för att förbättra tillgängligheten
  • Webbläsarens Web Audio API kräver en konvertering från base64 till PCM16 till Float32