Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Streaming audio in tempo reale

Lezione 12 di 18 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Streaming audio in tempo reale
  2. Streaming con le API TTS
  3. Misurazione della latenza
  4. Streaming asincrono
  5. Pre-caricamento del buffer
  6. Integrazione con una pipeline LLM + TTS
  7. Punti chiave

Aggiornamento 2 novembre 2026 — Modelli audio. Diversi modelli in questo corso sono deprecati: tts-1, tts-1-hd e gpt-4o-mini-tts smetteranno di funzionare il 6 gennaio 2027 (successore: gpt-realtime-2.1-mini, che la guida OpenAI TTS definisce non supportato da /v1/audio/speech: la migrazione della sintesi vocale passa alle API Realtime); gpt-realtime, gpt-4o-realtime e i modelli audio legacy il 20 gennaio 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe e /v1/audio/translations il 26 febbraio 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Per la voce full-duplex, GPT-Live 1 è disponibile nelle API dal 10 settembre 2026. Aggiornato il 3 novembre 2026: la pipeline LLM → TTS elaborava precedentemente qualsiasi evento contenente un campo delta, inclusi gli argomenti delle chiamate di funzione o i riepiloghi del ragionamento; ora filtra rigorosamente per response.output_text.delta, ovvero il testo effettivo della risposta.

Streaming audio in tempo reale

In un agente vocale, attendere la generazione dell’intero file audio prima di avviare la riproduzione introduce una latenza inaccettabile. Lo streaming TTS ti consente di avviare la riproduzione non appena arrivano i primi byte, riducendo il tempo per la prima risposta a poche centinaia di millisecondi.

Streaming con le API TTS

Le API TTS supportano nativamente lo streaming. Invece di attendere il file completo, ricevi l’audio in blocchi:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Genera e riproduce audio in modalità streaming."""
    # Inizializza il lettore audio
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Crea la risposta in streaming
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # PCM grezzo per la riproduzione diretta
        ) as response:
            # Leggi e riproduci blocco per blocco
            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.")

Il formato pcm è ideale per lo streaming perché non richiede decodifica: i byte grezzi sono pronti per la riproduzione immediata.

Misurazione della latenza

Il Time to First Byte (TTFB) è la metrica chiave per le prestazioni dello streaming:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Misura le latenze dello streaming 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")

Streaming asincrono

Per le applicazioni lato server, utilizza il client asincrono:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Streaming TTS asincrono per server."""
    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)
            # Qui invieresti il blocco al client tramite WebSocket
            yield chunk

# Utilizzo in un server 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"
    )

Pre-caricamento del buffer

Per garantire una riproduzione fluida senza interruzioni, accumula un piccolo buffer prima di iniziare:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Numero di blocchi da pre-caricare
):
    """Riproduzione TTS con buffer di pre-caricamento."""
    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
                    # Svuota il buffer iniziale
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Riproduci i blocchi rimanenti
        for remaining in buffer:
            player.write(remaining)

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

Integrazione con una pipeline LLM + TTS

In un agente vocale non basato su Realtime, puoi combinare lo streaming dell’LLM con lo streaming TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Streaming LLM → Streaming TTS in tempo reale."""
    # Fase 1: Accumula la risposta LLM per frase
    sentence_buffer = ""

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

    for event in stream:
        # Solo il testo della risposta deve essere parlato
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Rileva la fine della frase
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fase 2: Invia questa frase allo streaming TTS
                stream_tts_to_speaker(sentence)

    # Elabora il buffer rimanente
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Punti chiave

  • Lo streaming TTS riduce il TTFB a poche centinaia di millisecondi avviando la riproduzione prima del termine della generazione
  • Il formato pcm è ottimale per lo streaming: nessuna decodifica richiesta, riproduzione diretta
  • Un buffer di pre-caricamento di 2–3 blocchi previene le interruzioni all’inizio della riproduzione
  • Il client asincrono è essenziale per i server che gestiscono più connessioni simultanee
  • Combinare lo streaming LLM e lo streaming TTS consente di creare un agente vocale reattivo senza le API Realtime