Ir al contenido principal
Español— Elegir un idioma
Menú

Transmisión de audio en tiempo real

Lección 12 de 18 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Transmisión de audio en tiempo real
  2. Transmisión con la API de TTS
  3. Medición de la latencia
  4. Transmisión asíncrona
  5. Precarga del búfer
  6. Integración con una canalización LLM + TTS
  7. Puntos clave

Actualización 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos: tts-1, tts-1-hd y gpt-4o-mini-tts dejarán de funcionar el 6 de enero de 2027 (sustituto: gpt-realtime-2.1-mini, que la guía de TTS de OpenAI indica que no es compatible con /v1/audio/speech: la migración de la síntesis de voz se traslada a la API en tiempo real); gpt-realtime, gpt-4o-realtime y los modelos de audio herederos el 20 de enero de 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe y /v1/audio/translations el 26 de febrero de 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Para la voz a dúplex completo, GPT-Live 1 está disponible en la API desde el 10 de septiembre de 2026. Actualizado el 3 de noviembre de 2026: La canalización LLM → TTS procesaba anteriormente cualquier evento que contuviera un campo delta, incluidos los argumentos de llamadas a funciones o resúmenes de razonamiento; ahora filtra estrictamente response.output_text.delta, que es el texto real de la respuesta.

Transmisión de audio en tiempo real

En un agente de voz, esperar a que se genere el archivo de audio completo antes de iniciar la reproducción introduce una latencia inaceptable. La transmisión de TTS te permite comenzar la reproducción tan pronto como lleguen los primeros bytes, reduciendo el tiempo hasta la primera respuesta a unos pocos cientos de milisegundos.

Transmisión con la API de TTS

La API de TTS admite la transmisión de forma nativa. En lugar de esperar al archivo completo, recibes el audio en fragmentos:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Genera y reproduce audio en modo de transmisión."""
    # Inicializa el reproductor de audio
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Crea la respuesta en streaming
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # PCM crudo para reproducción directa
        ) as response:
            # Lee y reproduce fragmento a fragmento
            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.")

El formato pcm es ideal para la transmisión porque no requiere decodificación: los bytes crudos están listos para reproducirse de inmediato.

Medición de la latencia

El tiempo hasta el primer byte (TTFB, por sus siglas en inglés) es la métrica clave para el rendimiento de la transmisión:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mide las latencias de transmisión de 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")

Transmisión asíncrona

Para aplicaciones del lado del servidor, utiliza el cliente asíncrono:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Transmisión asíncrona de TTS 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)
            # Aquí enviarías el fragmento al cliente mediante WebSocket
            yield chunk

# Uso en un 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"
    )

Precarga del búfer

Para garantizar una reproducción fluida sin interrupciones, acumula un pequeño búfer antes de comenzar:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Número de fragmentos para precargar
):
    """Reproducción de TTS con un búfer de precarga."""
    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
                    # Vacia el búfer inicial
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Reproduce los fragmentos restantes
        for remaining in buffer:
            player.write(remaining)

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

Integración con una canalización LLM + TTS

En un agente de voz que no utiliza la API en tiempo real, puedes combinar la transmisión del LLM con la transmisión de TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Canalización: LLM en streaming → TTS en tiempo real."""
    # Fase 1: Acumular la respuesta del LLM por oraciones
    sentence_buffer = ""

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

    for event in stream:
        # Solo se debe hablar el texto de la respuesta
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detectar el final de la oración
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fase 2: Transmitir esta oración a TTS
                stream_tts_to_speaker(sentence)

    # Procesar el búfer restante
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Puntos clave

  • La transmisión de TTS reduce el TTFB a unos pocos cientos de milisegundos al iniciar la reproducción antes de que finalice la generación
  • El formato pcm es óptimo para la transmisión: no requiere decodificación, reproducción directa
  • Un búfer de precarga de 2–3 fragmentos evita interrupciones al inicio de la reproducción
  • El cliente asíncrono es esencial para servidores que gestionan múltiples conexiones simultáneas
  • Combinar un LLM en streaming con un TTS en streaming permite crear un agente de voz receptivo sin necesidad de la API en tiempo real