Enviar audio con input_audio_buffer.append
En esta página
Transmitir audio al servidor
Una vez configurada la sesión, puedes comenzar a transmitir audio al servidor. El evento input_audio_buffer.append envía fragmentos de audio codificados en base64.
Estructura del evento
{
"type": "input_audio_buffer.append",
"audio": "SGVsbG8gV29ybGQ..."
}
El campo audio contiene datos de audio sin procesar codificados en base64. Su formato debe coincidir con el configurado en session.update (por defecto, PCM de 16 bits little-endian a 24000 Hz).
Capturar audio en el navegador
La API Web Audio del navegador te permite capturar el micrófono y enviar los datos en tiempo 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);
}
Capturar audio en Python
Con la biblioteca pyaudio, puedes capturar el micrófono y enviar los fragmentos:
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
}))
Tamaño y frecuencia de los fragmentos
El tamaño del fragmento afecta a la latencia y al rendimiento:
- Fragmentos pequeños (1024 muestras / ~42 ms): latencia mínima, pero más mensajes WebSocket.
- Fragmentos medianos (4096 muestras / ~170 ms): un buen equilibrio.
- Fragmentos grandes (8192 muestras / ~341 ms): menos mensajes, pero latencia notable.
Para una conversación natural, envía un fragmento cada 100 a 200 ms. El VAD del servidor recoge los datos en un búfer interno y los procesa de forma continua.
Cancelación de eco
Si tu aplicación reproduce el audio de respuesta por los altavoces mientras el micrófono está activo, necesitas cancelación de eco. Sin ella, el agente se escucharía a sí mismo y podría acabar en un bucle de conversación consigo mismo.
Tus opciones son:
- Usar las opciones
echoCancellationynoiseSuppressionde la API Web Audio. - Silenciar el micrófono mientras el agente está hablando.
- Usar auriculares para aislar la entrada de la salida.
Puntos clave
input_audio_buffer.appendenvía fragmentos de audio codificados en base64.- El formato de los datos debe coincidir con la configuración de la sesión (PCM de 16 bits por defecto).
- Envía un fragmento cada 100 a 200 ms para lograr un buen equilibrio entre latencia y rendimiento.
- La captura de audio en el navegador usa la API Web Audio con una conversión de Float32 a PCM16.
- Gestiona la cancelación de eco para evitar bucles de audio.