Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A válaszhang fogadása és lejátszása

11. lecke 16 közül Frissítve 2026. július 30. Fejlesztő
Ezen az oldalon
  1. Streaming lejátszás
  2. Hanglejátszó architektúra
  3. Bekötés a WebSocket eseményekhez
  4. Megszakítások kezelése
  5. Hanglejátszó Pythonban
  6. Átirat megjelenítése hang mellett
  7. Főbb megállapítások

Streaming lejátszás

Amikor a hangalapú ügynök választ generál, a hang base64-kódolt darabokban (deltákban) érkezik. Az alkalmazásodnak dekódolnia kell ezeket, sorba kell állítania, és folyamatosan le kell játszania őket, hogy a felhasználó egy megszakítások nélküli, folyamatos választ halljon.

Hanglejátszó architektúra

Az elv egyszerű: minden egyes beérkező hangdelta dekódolásra kerül, és bekerül egy sorba. Egy lejátszási folyamat fogyasztja ezt a sort, és elküldi az adatokat a rendszer hangkimenetére:

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

  enqueue(pcm16ArrayBuffer) {
    // PCM16 konvertálása Float32-re a Web Audio API számára
    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;
  }
}

Bekötés a WebSocket eseményekhez

Így kötheted össze a hanglejátszót az API eseményeivel:

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":
      // A felhasználó megszakítja az ügynököt
      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;
}

Megszakítások kezelése

Egy természetes beszélgetés során a felhasználó megszakíthatja az ügynököt azzal, hogy belebeszél a válaszba. Az alkalmazásodnak kezelnie kell ezt a helyzetet:

  1. Megszakítás észlelése: a speech_started esemény megérkezik, miközben a hang lejátszása folyamatban van.
  2. Lejátszás leállítása: a hangsor ürítése és a hang elnémítása.
  3. Válasz megszakítása: a response.cancel elküldése, hogy a szerver abbahagyja a generálást.
  4. Figyelés: a felhasználóé a szó, és a ciklus újraindul.

Ez a „belebeszélés“ (barge-in) mechanizmus elengedhetetlen a gördülékeny beszélgetéshez. Enélkül a felhasználóknak meg kellene várniuk, amíg az ügynök befejezi a beszédet, mielőtt válaszolhatnának.

Hanglejátszó Pythonban

Python alkalmazás esetén a lejátszáshoz használhatod a pyaudio könyvtárat:

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

Átirat megjelenítése hang mellett

Amíg a hang lejátszása zajlik, valós időben megjelenítheted a válasz átiratát a response.output_audio_transcript.delta események segítségével. Így a felhasználók olvashatják is, amit az ügynök mond; ez zajos környezetben és az akadálymentesítés szempontjából is nagy segítség:

let currentTranscript = "";

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

Főbb megállapítások

  • A válaszhang base64-es darabokban érkezik a response.output_audio.delta eseményen keresztül.
  • Használj hangsort a folyamatos, hézagmentes lejátszás biztosításához.
  • Kezeld a megszakításokat (belebeszélést) a lejátszás leállításával és a válasz megszakításával.
  • Jelenítsd meg az átiratot a hang mellett az akadálymentesítés javítása érdekében.
  • A böngésző Web Audio API-ja base64-ből PCM16-on át Float32-be történő konverziót igényel.