Transmissão de áudio em tempo real
Nesta página
Atualização de 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos:
tts-1,tts-1-hdegpt-4o-mini-ttsdeixarã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-realtimee 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-transcribee/v1/audio/translationsa 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 campodelta, incluindo argumentos de chamada de função ou resumos de raciocínio; agora filtra estritamente porresponse.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