Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Invia audio con input_audio_buffer.append

Lezione 7 di 16 Aggiornata il 30 luglio 2026 Sviluppatore
In questa pagina
  1. Trasmetti audio al server
  2. Struttura dell’evento
  3. Acquisizione audio nel browser
  4. Acquisizione audio in Python
  5. Dimensione e frequenza dei blocchi
  6. Cancellazione dell’eco
  7. Punti chiave

Trasmetti audio al server

Una volta configurata la sessione, puoi iniziare a trasmettere audio al server. L’evento input_audio_buffer.append invia blocchi di audio codificati in base64.

Struttura dell’evento

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

Il campo audio contiene dati audio grezzi codificati in base64. Il suo formato deve corrispondere a quello configurato in session.update (di default, PCM a 16 bit little-endian a 24000 Hz).

Acquisizione audio nel browser

Le Web Audio API del browser ti permettono di catturare il microfono e inviare i dati in tempo reale:

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

Acquisizione audio in Python

Con la libreria pyaudio, puoi catturare l’audio dal microfono e inviare i blocchi:

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

Dimensione e frequenza dei blocchi

La dimensione del blocco influisce sulla latenza e sulle prestazioni:

  • Blocchi piccoli (1024 campioni / ~42 ms): latenza minima, ma più messaggi WebSocket
  • Blocchi medi (4096 campioni / ~170 ms): un buon compromesso
  • Blocchi grandi (8192 campioni / ~341 ms): meno messaggi, ma latenza percepibile

Per una conversazione naturale, invia un blocco ogni 100-200 ms. Il VAD del server raccoglie i dati in un buffer interno e li elabora continuamente.

Cancellazione dell’eco

Se la tua applicazione riproduce l’audio di risposta dagli altoparlanti mentre il microfono è attivo, hai bisogno della cancellazione dell’eco. Senza di essa, l’agente sentirebbe se stesso parlare e potrebbe finire in un ciclo di conversazione con se stesso.

Le tue opzioni:

  • Usa le opzioni echoCancellation e noiseSuppression delle Web Audio API
  • Disattiva il microfono mentre l’agente sta parlando
  • Usa una cuffia per isolare l’input dall’output

Punti chiave

  • input_audio_buffer.append invia blocchi audio codificati in base64
  • Il formato dei dati deve corrispondere alla configurazione della sessione (PCM a 16 bit di default)
  • Invia un blocco ogni 100-200 ms per un buon equilibrio tra latenza e prestazioni
  • L’acquisizione audio nel browser usa le Web Audio API con una conversione da Float32 a PCM16
  • Gestisci la cancellazione dell’eco per evitare loop audio