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

Transmissão de Áudio Bidirecional

Aula 3 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Transmissão de Áudio Bidirecional
  2. Formato de Áudio PCM16
  3. Envio de Áudio: Captura do Microfone
  4. Receção de Áudio de Resposta
  5. Aplicação Completa: Conversa por Voz
  6. Pontos-chave

Atualizado em 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos: tts-1, tts-1-hd e gpt-4o-mini-tts deixarão de funcionar a 6 de janeiro de 2027 (a substituição indicada é gpt-realtime-2.1-mini, que o guia TTS da OpenAI afirma não ser suportada por /v1/audio/speech: a migração da síntese de fala passa para a Realtime API); gpt-realtime, gpt-4o-realtime e modelos de áudio legados a 20 de janeiro de 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe e /v1/audio/translations a 26 de fevereiro de 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Para voz em full-duplex, o GPT-Live 1 está disponível na API desde 10 de setembro de 2026.

Transmissão de Áudio Bidirecional

A transmissão de áudio bidirecional é o núcleo da Realtime API. O seu sistema envia continuamente fragmentos de áudio do microfone e o modelo devolve continuamente fragmentos de áudio de resposta. Estes dois fluxos são independentes e podem operar simultaneamente — é isto que torna a conversa natural.

Formato de Áudio PCM16

A Realtime API utiliza o formato PCM de 16 bits, mono, a 24 kHz. Trata-se de um formato bruto e não comprimido: cada amostra é um inteiro com sinal de 16 bits. Esta escolha privilegia a baixa latência em detrimento da eficiência da largura de banda.

24 kHz
Taxa de amostragem
16 bit
Profundidade da amostra
Mono
Canal único
48 KB/s
Taxa de bits de áudio bruto

Os fragmentos de áudio são enviados codificados em Base64 dentro de eventos JSON. Cada fragmento representa tipicamente entre 20 a 100 ms de áudio.

Envio de Áudio: Captura do Microfone

Eis como capturar o microfone e transmitir o áudio:

import asyncio
import sounddevice as sd
import numpy as np
import base64
import json

SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)

async def stream_microphone(ws):
    """Capture o microfone e envie fragmentos para a Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Aviso de áudio: {status}")
        # Converter para int16 e colocar na fila
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Iniciar captura
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Microfone ativo — fale agora...")
        while True:
            pcm_data = await audio_queue.get()
            audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")

            await ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": audio_b64
            }))

O Buffer de Áudio no Servidor

Os fragmentos enviados através de input_audio_buffer.append acumulam-se num buffer no servidor. Este buffer é processado de duas formas:

  • Modo VAD automático (server_vad): O servidor deteta quando deixa de falar e confirma automaticamente o buffer.
  • Modo manual: Envia explicitamente input_audio_buffer.commit para acionar o processamento.
# Confirmar manualmente o buffer de áudio
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Ou limpar o buffer sem o processar
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Receção de Áudio de Resposta

As respostas de áudio chegam em fragmentos através de eventos response.output_audio.delta. Deve descodificá-los e reproduzi-los continuamente:

import pyaudio

async def play_response_audio(ws):
    """Receber e reproduzir áudio de resposta."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=SAMPLE_RATE,
        output=True,
        frames_per_buffer=CHUNK_SIZE
    )

    try:
        async for raw_message in ws:
            event = json.loads(raw_message)

            if event["type"] == "response.output_audio.delta":
                # Descodificar o fragmento de áudio Base64
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Resposta de áudio terminada")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Transcrição de texto da resposta
                print(event["delta"], end="", flush=True)

    finally:
        player.stop_stream()
        player.close()
        pa.terminate()

Aplicação Completa: Conversa por Voz

Eis como montar a captura e a reprodução para uma conversa completa:

async def conversation_vocale():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Aguardar session.created
        await ws.recv()

        # Configurar a sessão
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "You are a voice assistant. Respond in English.",
                "audio": {
                    "input": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 700
                        }
                    },
                    "output": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "voice": "marin"
                    }
                }
            }
        }))
        await ws.recv()  # session.updated

        # Lançar captura e reprodução em paralelo
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Gestão de Fluxos Concorrentes

O desafio da transmissão bidirecional reside no facto de estar a enviar e a receber simultaneamente no mesmo WebSocket. O asyncio.gather lança ambas as corrotinas em paralelo, mas estas partilham o mesmo objeto WebSocket. A biblioteca websockets gere esta concorrência corretamente.

Pontos-chave

  • O áudio é transmitido como PCM mono de 16 bits a 24 kHz, codificado em Base64 em eventos JSON
  • Os fragmentos têm tipicamente entre 20 a 100 ms de áudio para um bom equilíbrio entre latência e sobrecarga
  • O buffer de áudio no servidor acumula fragmentos até à confirmação (automática no modo VAD)
  • A reprodução da resposta ocorre fragmento a fragmento através de response.output_audio.delta
  • O asyncio.gather permite a captura e reprodução simultâneas no mesmo WebSocket