Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Vasta heli vastuvõtt ja esitamine

Õppetund 11 / 16 Värskendatud 30. juuli 2026 Arendajatele
Sellel lehel
  1. Voogedastuse taasesitus
  2. Helimängija arhitektuur
  3. Ühendamine WebSocketi sündmustega
  4. Katkestuste käsitlemine
  5. Helimängija Pythonis
  6. Transkriptsiooni näitamine kõrvuti
  7. Peamised punktid

Voogedastuse taasesitus

Kui häälagent vastuse genereerib, saabub heli base64-kodeeritud tükkidena (deltad). Sinu rakendus peab need dekodeerima, järjekorda panema ja sujuvalt esitama, et kasutaja kuuleks ühtset vastust ilma katkestusteta.

Helimängija arhitektuur

Põhimõte on lihtne: iga saabuv helidelta dekodeeritakse ja lisatakse järjekorda. Taasesitusprotsess tarbib järjekorda ja saadab andmed süsteemi heliväljundisse:

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

  enqueue(pcm16ArrayBuffer) {
    // Teisenda PCM16 Float32-ks Web Audio API jaoks
    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;
  }
}

Ühendamine WebSocketi sündmustega

Siin on näide, kuidas ühendada helimängija API sündmustega:

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":
      // Kasutaja katkestab agenti
      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;
}

Katkestuste käsitlemine

Loomulikus vestluses võib kasutaja agenti katkestada, rääkides üle tema vastuse. Sinu rakendus peab sellega arvestama:

  1. Tuvasta katkestus: sündmus speech_started saabub heli esitamise ajal.
  2. Peata taasesitus: tühjenda helijärjekord ja lõpeta heli.
  3. Tühista vastus: saada response.cancel, et server lõpetaks genereerimise.
  4. Kuula: nüüd on sõna kasutajal ja tsükkel algab uuesti.

See „vahelesegamise“ (barge-in) mehhanism on sujuva vestluse jaoks hädavajalik. Ilma selleta peaksid kasutajad ootama, kuni agent oma jutu lõpetab, enne kui nad saavad vastata.

Helimängija Pythonis

Pythoni rakenduse saad kasutada taasesituseks teeki 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()

Transkriptsiooni näitamine kõrvuti

Samal ajal kui heli mängib, saad reaalajas kuvada vastuse transkriptsiooni, kasutades sündmusi response.output_audio_transcript.delta. Kasutajad saavad siis lugeda, mida agent ütleb, mis on abiks mürasetes keskkondades ja ligipääsetavuse tagamiseks:

let currentTranscript = "";

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

Peamised punktid

  • Vastuse heli saabub base64-tükkidena läbi response.output_audio.delta
  • Kasuta helijärjekorda, et tagada katkestusteta pidev taasesitus
  • Käitle katkestusi (vahelesegamine), peatades taasesituse ja tühistades vastuse
  • Kuva transkriptsioon heli kõrval, et parandada ligipääsetavust
  • Brauseri Web Audio API nõuab teisendust base64 → PCM16 → Float32