Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Enviar áudio com input_audio_buffer.append

Aula 7 de 16 Atualizada a 30 de julho de 2026 Programador
Nesta página
  1. Transmitir áudio para o servidor
  2. Estrutura do evento
  3. Capturar áudio no navegador
  4. Capturar áudio em Python
  5. Tamanho e frequência dos fragmentos
  6. Cancelamento de eco
  7. Pontos-chave

Transmitir áudio para o servidor

Assim que a sessão estiver configurada, pode começar a transmitir áudio para o servidor. O evento input_audio_buffer.append envia fragmentos de áudio codificados em base64.

Estrutura do evento

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

O campo audio contém dados de áudio brutos codificados em base64. O seu formato deve corresponder ao configurado em session.update (por predefinição, PCM little-endian de 16 bits a 24000 Hz).

Capturar áudio no navegador

A API Web Audio do navegador permite capturar o microfone e enviar os dados em tempo 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 áudio em Python

Com a biblioteca pyaudio, pode capturar o microfone e enviar os 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
        }))

Tamanho e frequência dos fragmentos

O tamanho do fragmento afeta a latência e o desempenho:

  • Fragmentos pequenos (1024 amostras / ~42 ms): latência mínima, mas mais mensagens WebSocket
  • Fragmentos médios (4096 amostras / ~170 ms): um bom equilíbrio
  • Fragmentos grandes (8192 amostras / ~341 ms): menos mensagens, mas latência perceptível

Para uma conversa natural, envie um fragmento a cada 100 a 200 ms. O VAD do servidor recolhe os dados num buffer interno e processa-os continuamente.

Cancelamento de eco

Se a sua aplicação reproduzir o áudio da resposta através dos altifalantes enquanto o microfone está ativo, necessita de cancelamento de eco. Sem isto, o agente ouvir-se-ia a si próprio e poderia entrar num ciclo de conversa consigo mesmo.

As suas opções:

  • Utilizar as opções echoCancellation e noiseSuppression da API Web Audio
  • Silenciar o microfone enquanto o agente estiver a falar
  • Utilizar um auricular para isolar a entrada da saída

Pontos-chave

  • input_audio_buffer.append envia fragmentos de áudio codificados em base64
  • O formato dos dados deve corresponder à configuração da sessão (PCM de 16 bits por predefinição)
  • Envie um fragmento a cada 100 a 200 ms para um bom equilíbrio entre latência e desempenho
  • A captura de áudio no navegador utiliza a API Web Audio com uma conversão de Float32 para PCM16
  • Trate o cancelamento de eco para evitar ciclos de áudio