Salt la conținutul principal
Română— Alege o limbă
Meniu

Trimiteți audio cu input_audio_buffer.append

Lecția 7 din 16 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Transmiteți fluxul audio către server
  2. Structura evenimentului
  3. Captarea audio în browser
  4. Captarea audio în Python
  5. Dimensiunea fragmentelor și frecvența
  6. Anularea ecoului
  7. Puncte cheie

Transmiteți fluxul audio către server

Odată ce sesiunea este configurată, puteți începe transmiterea fluxului audio către server. Evenimentul input_audio_buffer.append trimite fragmente de audio codificate în base64.

Structura evenimentului

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

Câmpul audio conține date audio brute codificate în base64. Formatul său trebuie să corespundă celui configurat în session.update (implicit, PCM pe 16 biți little-endian la 24000 Hz).

Captarea audio în browser

API-ul Web Audio al browserului vă permite să capturați microfonul și să trimiteți datele în timp real:

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

Captarea audio în Python

Cu biblioteca pyaudio, puteți captura microfonul și trimite fragmentele de date:

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

Dimensiunea fragmentelor și frecvența

Dimensiunea fragmentului afectează latența și performanța:

  • Fragmente mici (1024 eșantioane / ~42 ms): latență minimă, dar mai multe mesaje WebSocket
  • Fragmente medii (4096 eșantioane / ~170 ms): un compromis bun
  • Fragmente mari (8192 eșantioane / ~341 ms): mai puține mesaje, dar latență vizibilă

Pentru o conversație naturală, trimiteți un fragment la fiecare 100 până la 200 ms. VAD-ul serverului colectează datele într-un buffer intern și le procesează continuu.

Anularea ecoului

Dacă aplicația dumneavoastră redă audio-ul de răspuns prin difuzoare în timp ce microfonul este activ, aveți nevoie de anularea ecoului. Fără aceasta, agentul s-ar auzi singur vorbind și ar putea intra într-o buclă de conversație cu sine însuși.

Opțiunile dumneavoastră:

  • Utilizați opțiunile echoCancellation și noiseSuppression din API-ul Web Audio
  • Dezactivați microfonul în timp ce agentul vorbește
  • Utilizați o cască pentru a izola intrarea de ieșire

Puncte cheie

  • input_audio_buffer.append trimite fragmente de audio codificate în base64
  • Formatul datelor trebuie să corespundă configurației sesiunii (implicit PCM pe 16 biți)
  • Trimiteți un fragment la fiecare 100–200 ms pentru un echilibru bun între latență și performanță
  • Captarea audio în browser utilizează API-ul Web Audio cu o conversie de la Float32 la PCM16
  • Gestionați anularea ecoului pentru a evita buclele audio