Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pošiljanje zvoka z input_audio_buffer.append

Lekcija 7 od 16 Posodobljeno 30. julij 2026 Razvijalec
Na tej strani
  1. Pretakanje zvoka na strežnik
  2. Struktura dogodka
  3. Zajem zvoka v brskalniku
  4. Zajem zvoka v Pythonu
  5. Velikost dela in pogostost
  6. Odprava odmeva
  7. Ključne ugotovitve

Pretakanje zvoka na strežnik

Ko je seja konfigurirana, lahko začneš pretakati zvok na strežnik. Dogodek input_audio_buffer.append pošilja dele zvoka, kodirane v base64.

Struktura dogodka

{
  "type": "input_audio_buffer.append",
  "audio": "SGVsbG8gV29ybGQ..."
}

Polje audio vsebuje surove zvočne podatke, kodirane v base64. Njegova oblika se mora ujemati s tisto, konfigurirano v session.update (privzeto 16-bitni PCM z little-endian zapisom pri 24000 Hz).

Zajem zvoka v brskalniku

Web Audio API brskalnika ti omogoča zajem mikrofona in pošiljanje podatkov v realnem času:

async function startCapture(ws) {
  const stream = await navigator.mediaDevices.getUserMedia({
    audio: {
      sampleRate: 24000,
      channelCount: 1,
      echoCancellation: true,
      noiseSuppression: true
    }
  });

  const audioContext = new AudioContext({ sampleRate: 24000 });
  const source = audioContext.createMediaStreamSource(stream);
  const processor = audioContext.createScriptProcessor(4096, 1, 1);

  processor.onaudioprocess = (event) => {
    const inputData = event.inputBuffer.getChannelData(0);
    const pcm16 = float32ToPCM16(inputData);
    const base64 = arrayBufferToBase64(pcm16.buffer);

    ws.send(JSON.stringify({
      type: "input_audio_buffer.append",
      audio: base64
    }));
  };

  source.connect(processor);
  processor.connect(audioContext.destination);
}

function float32ToPCM16(float32Array) {
  const pcm16 = new Int16Array(float32Array.length);
  for (let i = 0; i < float32Array.length; i++) {
    const s = Math.max(-1, Math.min(1, float32Array[i]));
    pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
  }
  return pcm16;
}

function arrayBufferToBase64(buffer) {
  const bytes = new Uint8Array(buffer);
  let binary = "";
  for (let i = 0; i < bytes.byteLength; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  return btoa(binary);
}

Zajem zvoka v Pythonu

S knjižnico pyaudio lahko zajameš mikrofon in pošlješ dele podatkov:

import pyaudio
import base64
import json

RATE = 24000
CHUNK = 4096
FORMAT = pyaudio.paInt16
CHANNELS = 1

p = pyaudio.PyAudio()
stream = p.open(
    format=FORMAT,
    channels=CHANNELS,
    rate=RATE,
    input=True,
    frames_per_buffer=CHUNK
)

async def send_audio(ws):
    while True:
        data = stream.read(CHUNK, exception_on_overflow=False)
        audio_b64 = base64.b64encode(data).decode("utf-8")
        await ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": audio_b64
        }))

Velikost dela in pogostost

Velikost dela vpliva na zakasnitev in zmogljivost:

  • Majhni deli (1024 vzorcev / ~42 ms): minimalna zakasnitev, a več sporočil WebSocket
  • Srednji deli (4096 vzorcev / ~170 ms): dobro ravnovesje
  • Veliki deli (8192 vzorcev / ~341 ms): manj sporočil, a opazna zakasnitev

Za naraven pogovor pošlji del vsakih 100 do 200 ms. Strežnikov VAD zbira podatke v notranji medpomnilnik in jih neprekinjeno obdeluje.

Odprava odmeva

Če tvoja aplikacija predvaja odzivni zvok skozi zvočnike, medtem ko je mikrofon vklopljen, potrebuješ odpravo odmeva. Brez nje bi agent slišal samega sebe in bi lahko zašel v zanko pogovora sam s seboj.

Tvoje možnosti:

  • Uporabi možnosti echoCancellation in noiseSuppression v Web Audio API
  • Utišaj mikrofon, medtem ko agent govori
  • Uporabi slušalke za izolacijo vhoda od izhoda

Ključne ugotovitve

  • input_audio_buffer.append pošilja dele zvoka, kodirane v base64
  • Oblika podatkov se mora ujemati s konfiguracijo seje (privzeto 16-bitni PCM)
  • Za dobro ravnovesje med zakasnitvijo in zmogljivostjo pošlji del vsakih 100 do 200 ms
  • Zajem zvoka v brskalniku uporablja Web Audio API s pretvorbo Float32 v PCM16
  • Obdelaj odpravo odmeva, da se izogneš zankam zvoka