Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Saņem un atskaņo atbildes audio

Nodarbība 11 no 16 Atjaunota 2026. gada 30. jūlijs Programmētājs
Šajā lapā
  1. Straumēta atskaņošana
  2. Audio atskaņotāja arhitektūra
  3. Savienojums ar WebSocket notikumiem
  4. Pārtraukumu apstrāde
  5. Audio atskaņotājs valodā Python
  6. Transkripta rādīšana līdztekus
  7. Galvenās atziņas

Straumēta atskaņošana

Kad balss aģents ģenerē atbildi, audio ierodas bāzes64 kodētās daļās (deltas). Tavai lietotnei tās ir jāatšifrē, jāievieto rindā un jāatskaņo vienmērīgi, lai lietotājs dzirdētu vienu nepārtrauktu atbildi bez pauzēm.

Audio atskaņotāja arhitektūra

Princips ir vienkāršs: katru saņemto audio deltu atšifrē un pievieno rindai. Atskaņošanas process patērē šo rindu un nosūta datus sistēmas audio izejai:

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

Savienojums ar WebSocket notikumiem

Lūk, kā savienot audio atskaņotāju ar API notikumiem:

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

Pārtraukumu apstrāde

Dabiskā sarunā lietotājs var pārtraukt aģentu, runājot tam pāri atbildes laikā. Tavai lietotnei tas ir jāapstrādā:

  1. Noteic pārtraukumu: notikums speech_started ierodas, kamēr audio tiek atskaņots.
  2. Apturi atskaņošanu: iztukšo audio rindu un pārtrauc skaņu.
  3. Atceļ atbildi: nosūti response.cancel, lai serveris pārtrauktu ģenerēšanu.
  4. Klausies: lietotājam ir vārds, un cikls sākas no jauna.

Šis „barge-in” mehānisms ir būtisks plūstošai sarunai. Bez tā lietotājiem būtu jāgaida, līdz aģents beidz runāt, pirms viņi varētu atbildēt.

Audio atskaņotājs valodā Python

Python lietotnei atskaņošanai vari izmantot 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()

Transkripta rādīšana līdztekus

Kamēr audio tiek atskaņots, tu vari reāllaikā parādīt atbildes transkriptu, izmantojot notikumus response.output_audio_transcript.delta. Lietotāji tad var lasīt to, ko aģents saka, kas palīdz trokšņainā vidē un nodrošina pieejamību:

let currentTranscript = "";

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

Galvenās atziņas

  • Atbildes audio ierodas kā bāzes64 fragmenti, izmantojot response.output_audio.delta.
  • Izmanto audio rindu, lai garantētu nepārtrauktu atskaņošanu bez pauzēm.
  • Apstrādā pārtraukumus (barge-in), apturot atskaņošanu un atceļot atbildi.
  • Rādi transkriptu līdztekus audio, lai uzlabotu pieejamību.
  • Pārlūka Web Audio API ir nepieciešama konvertēšana no bāzes64 uz PCM16 un tālāk uz Float32.