Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Gauti ir atkurti atsakymo garso įrašą

Paskaita 11 iš 16 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Srautinis atkūrimas
  2. Garso grotuvo architektūra
  3. Susiejimas su „WebSocket“ įvykiais
  4. Pertraukimų valdymas
  5. Garso grotuvas „Python“ kalboje
  6. Transkripcijos rodymas šalia
  7. Svarbiausi punktai

Srautinis atkūrimas

Kai balso agentas sugeneruoja atsakymą, garso duomenys atkeliauja „base64“ koduotomis dalimis (delta). Tavo programėlė turi jas iššifruoti, sudėti į eilę ir atkurti taip sklandžiai, kad vartotojas išgirstų vientisą atsakymą be jokių tarpų.

Garso grotuvo architektūra

Principas paprastas: kiekvieną gautą garso deltą iššifruoji ir pridedi į eilę. Atkūrimo procesas sunaudoja eilės elementus ir siunčia duomenis į sistemos garso išvestį:

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

Susiejimas su „WebSocket“ įvykiais

Štai kaip prijungti garso grotuvą prie API įvykių:

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

Pertraukimų valdymas

Natūralaus pokalbio metu vartotojas gali pertraukti agentą pradėdamas kalbėti jam dar nebaigus atsakymo. Tavo programėlė turi tai apdoroti:

  1. Aptikti pertraukimą: įvykis speech_started atkeliauja, kai vis dar atkuriamas garsas.
  2. Sustabdyti atkūrimą: išvalyti garso eilę ir nutildyti garsą.
  3. Atšaukti atsakymą: išsiųsti response.cancel, kad serveris nustotų generuoti turinį.
  4. Klausytis: žodis priklauso vartotojui, ir ciklas prasideda iš naujo.

Šis „barge-in“ mechanizmas yra būtinas sklandžiam pokalbiui. Be jo vartotojai turėtų laukti, kol agentas baigs kalbėti, prieš galėdami atsakyti.

Garso grotuvas „Python“ kalboje

„Python“ programėlėms atkurti gali naudoti pyaudio:

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

Transkripcijos rodymas šalia

Kol atkuriamas garsas, realiuoju laiku gali rodyti atsakymo transkripciją naudodamas įvykius response.output_audio_transcript.delta. Vartotojai taip gali skaityti, ką agentas sako, o tai padeda triukšmingoje aplinkoje ir gerina prieinamumą:

let currentTranscript = "";

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

Svarbiausi punktai

  • Atsakymo garso duomenys atkeliauja „base64“ gabalėliais per response.output_audio.delta.
  • Naudok garso eilę, kad užtikrintum vientisą atkūrimą be tarpų.
  • Valdyk pertraukimus („barge-in“) sustabdydamas atkūrimą ir atšaukdamas atsakymą.
  • Rodyk transkripciją šalia garso, kad pagerintum prieinamumą.
  • Naršyklės „Web Audio API“ reikalauja konvertuoti iš „base64“ į PCM16, o tada į Float32.