Salt la conținutul principal
Română— Alege o limbă
Meniu

Recepționarea și redarea răspunsului audio

Lecția 11 din 16 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Redare în flux continuu
  2. Arhitectura player-ului audio
  3. Conectarea la evenimentele WebSocket
  4. Gestionarea întreruperilor
  5. Player audio în Python
  6. Afișarea transcrierii în paralel
  7. Puncte cheie

Redare în flux continuu

Când agentul vocal generează un răspuns, audio-ul sosește sub formă de fragmente codificate în base64 (deltă). Aplicația dumneavoastră trebuie să le decodeze, să le pună în coadă și să le redea fluid, astfel încât utilizatorul să audă un răspuns continuu, fără întreruperi.

Arhitectura player-ului audio

Principiul este simplu: fiecare deltă audio recepționată este decodată și adăugată într-o coadă. Un proces de redare consumă această coadă și trimite datele către ieșirea audio a sistemului:

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

  enqueue(pcm16ArrayBuffer) {
    // Convertire PCM16 în Float32 pentru 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;
  }
}

Conectarea la evenimentele WebSocket

Iată cum să conectați player-ul audio la evenimentele API-ului:

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":
      // Utilizatorul întrerupe agentul
      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;
}

Gestionarea întreruperilor

Într-o conversație naturală, utilizatorul poate întrerupe agentul vorbind peste răspunsul acestuia. Aplicația dumneavoastră trebuie să gestioneze această situație:

  1. Detectarea întreruperii: evenimentul speech_started sosește în timp ce audio-ul este în curs de redare.
  2. Oprirea redării: golirea cozii audio și oprirea sunetului.
  3. Anularea răspunsului: trimiterea comenzii response.cancel pentru ca serverul să oprească generarea.
  4. Ascultarea: utilizatorul preia inițiativa, iar ciclul reîncepe.

Acest mecanism de „barge-in“ (întrerupere) este esențial pentru o conversație fluidă. Fără el, utilizatorii ar fi nevoiți să aștepte ca agentul să termine de vorbit înainte de a putea răspunde.

Player audio în Python

Pentru o aplicație Python, puteți utiliza pyaudio pentru redare:

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

Afișarea transcrierii în paralel

În timp ce audio-ul este redat, puteți afișa transcrierea răspunsului în timp real folosind evenimentele response.output_audio_transcript.delta. Utilizatorii pot astfel citi ceea ce spune agentul, lucru util în medii zgomotoase și pentru accesibilitate:

let currentTranscript = "";

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

Puncte cheie

  • Audio-ul de răspuns sosește sub formă de fragmente base64 prin response.output_audio.delta
  • Utilizați o coadă audio pentru a garanta o redare continuă, fără goluri
  • Gestionați întreruperile (barge-in) oprind redarea și anulând răspunsul
  • Afișați transcrierea alături de audio pentru a îmbunătăți accesibilitatea
  • Web Audio API din browser necesită o conversie de la base64 la PCM16, apoi la Float32