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

Transmissão de áudio em tempo real

Aula 12 de 18 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Transmissão de áudio em tempo real
  2. Transmissão com a API TTS
  3. Medição da latência
  4. Transmissão assíncrona
  5. Pré-preenchimento do buffer
  6. Integração num pipeline LLM + TTS
  7. Pontos-chave

Atualização de 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 (sucessor: gpt-realtime-2.1-mini, que o guia TTS da OpenAI indica não ser suportado por /v1/audio/speech: a migração da síntese de voz 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 full-duplex, o GPT-Live 1 está disponível na API desde 10 de setembro de 2026. Atualizado em 3 de novembro de 2026: O pipeline LLM → TTS processava anteriormente qualquer evento com um campo delta, incluindo argumentos de chamada de função ou resumos de raciocínio; agora filtra estritamente por response.output_text.delta, o texto real da resposta.

Transmissão de áudio em tempo real

Num agente de voz, esperar que todo o ficheiro de áudio seja gerado antes de iniciar a reprodução introduz uma latência inaceitável. A transmissão TTS permite iniciar a reprodução assim que chegam os primeiros bytes, reduzindo o tempo até à primeira resposta para algumas centenas de milissegundos.

Transmissão com a API TTS

A API TTS suporta transmissão nativamente. Em vez de esperar pelo ficheiro completo, recebe o áudio em blocos:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Gera e reproduz áudio em modo de transmissão."""
    # Inicializa o leitor de áudio
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Cria a resposta em transmissão
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # PCM bruto para reprodução direta
        ) as response:
            # Lê e reproduz bloco a bloco
            for chunk in response.iter_bytes(chunk_size=4096):
                player.write(chunk)

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

stream_tts_to_speaker("Hello, here is a real-time streaming response.")

O formato pcm é ideal para transmissão porque não requer descodificação: os bytes brutos estão prontos para reprodução imediata.

Medição da latência

O Tempo até ao Primeiro Byte (TTFB) é a métrica chave para o desempenho da transmissão:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mede as latências de transmissão TTS."""
    start_time = time.time()
    first_byte_time = None
    total_bytes = 0

    with client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        for chunk in response.iter_bytes(chunk_size=4096):
            if first_byte_time is None:
                first_byte_time = time.time()
            total_bytes += len(chunk)

    end_time = time.time()

    return {
        "ttfb_ms": round((first_byte_time - start_time) * 1000),
        "total_ms": round((end_time - start_time) * 1000),
        "total_bytes": total_bytes,
        "audio_duration_s": round(total_bytes / (24000 * 2), 2)
    }

metrics = measure_tts_latency("Hello, how are you?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Total: {metrics['total_ms']}ms")

Transmissão assíncrona

Para aplicações do lado do servidor, utilize o cliente assíncrono:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Transmissão TTS assíncrona para servidores."""
    chunks = []

    async with async_client.audio.speech.with_streaming_response.create(
        model="tts-1",
        voice=voice,
        input=text,
        response_format="pcm"
    ) as response:
        async for chunk in response.iter_bytes(chunk_size=4096):
            chunks.append(chunk)
            # Aqui, enviaria o bloco ao cliente via WebSocket
            yield chunk

# Utilização num servidor FastAPI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/tts/stream")
async def tts_stream(text: str, voice: str = "alloy"):
    return StreamingResponse(
        stream_tts_async(text, voice),
        media_type="audio/pcm"
    )

Pré-preenchimento do buffer

Para garantir uma reprodução fluida sem falhas, acumule um pequeno buffer antes de iniciar:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Número de blocos para pré-carregar
):
    """Reprodução TTS com buffer de pré-preenchimento."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    buffer = []
    playback_started = False

    try:
        async with async_client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"
        ) as response:
            async for chunk in response.iter_bytes(chunk_size=4096):
                buffer.append(chunk)

                if not playback_started and len(buffer) >= buffer_size:
                    playback_started = True
                    # Esvazia o buffer inicial
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Reproduz os blocos restantes
        for remaining in buffer:
            player.write(remaining)

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

Integração num pipeline LLM + TTS

Num agente de voz não-Realtime, pode combinar a transmissão do LLM com a transmissão TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: LLM em transmissão → TTS em tempo real."""
    # Fase 1: Acumular resposta do LLM por frase
    sentence_buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-luna",
        input=[{"role": "user", "content": user_message}],
        stream=True
    )

    for event in stream:
        # Apenas o texto da resposta deve ser falado
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detetar fim de frase
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fase 2: Transmitir esta frase para TTS
                stream_tts_to_speaker(sentence)

    # Processar o buffer restante
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Pontos-chave

  • A transmissão TTS reduz o TTFB para algumas centenas de milissegundos ao iniciar a reprodução antes do fim da geração
  • O formato pcm é ótimo para transmissão: não requer descodificação, reprodução direta
  • Um buffer de pré-preenchimento de 2–3 blocos previne falhas no início da reprodução
  • O cliente assíncrono é essencial para servidores que gerem múltiplas ligações simultâneas
  • Combinar LLM em transmissão e TTS em transmissão permite um agente de voz responsivo sem a Realtime API