Salt la conținutul principal
Română— Alege o limbă
Meniu

Flux audio în timp real

Lecția 12 din 18 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Flux audio în timp real
  2. Flux cu API-ul TTS
  3. Măsurarea latenței
  4. Flux asincron
  5. Pre-umplerea tamponului
  6. Integrarea cu un pipeline LLM + TTS
  7. Puncte cheie

Actualizare 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor înceta să funcționeze la 6 ianuarie 2027 (succesor: gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de /v1/audio/speech: migrarea sintezei vocale se mută către API-ul Realtime); gpt-realtime, gpt-4o-realtime și modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe și /v1/audio/translations la 26 februarie 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026. Actualizat 3 noiembrie 2026: Pipeline-ul LLM → TTS procesa anterior orice eveniment care conținea un câmp delta, inclusiv argumente de apelare a funcțiilor sau rezumate de raționament; acum filtrează strict pentru response.output_text.delta, textul real al răspunsului.

Flux audio în timp real

În cazul unui agent vocal, așteptarea generării întregului fișier audio înainte de a începe redarea introduce o latență inacceptabilă. Fluxul TTS vă permite să începeți redarea imediat ce sosesc primii octeți, reducând timpul până la primul răspuns la câteva sute de milisecunde.

Flux cu API-ul TTS

API-ul TTS suportă nativ fluxul de date. În loc să așteptați fișierul complet, primiți audio în blocuri:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generează și redă audio în mod flux."""
    # Inițializează playerul audio
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Creează răspunsul flux
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # PCM brut pentru redare directă
        ) as response:
            # Citește și redă bloc cu bloc
            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.")

Formatul pcm este ideal pentru flux deoarece nu necesită decodare: octeții brute sunt gata de redare imediat.

Măsurarea latenței

Timpul până la primul octet (TTFB) este metrica cheie pentru performanța fluxului:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Măsoară latențele fluxului 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")

Flux asincron

Pentru aplicațiile lato-server, utilizați clientul asincron:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Flux TTS asincron pentru servere."""
    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)
            # Aici, ați trimite blocul către client prin WebSocket
            yield chunk

# Utilizare într-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-umplerea tamponului

Pentru a asigura o redare fluidă fără întreruperi, acumulați un mic tampon înainte de a începe:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Număr de blocuri de preîncărcat
):
    """Redare TTS cu tampon de pre-umplere."""
    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
                    # Golire tampon inițial
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Redă blocurile rămase
        for remaining in buffer:
            player.write(remaining)

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

Integrarea cu un pipeline LLM + TTS

Într-un agent vocal non-Realtime, puteți combina fluxul LLM cu fluxul TTS:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Flux LLM → Flux TTS în timp real."""
    # Faza 1: Acumulare răspuns LLM pe propoziții
    sentence_buffer = ""

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

    for event in stream:
        # Doar textul răspunsului trebuie rostit
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detectare sfârșit de propoziție
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Faza 2: Flux acestei propoziții către TTS
                stream_tts_to_speaker(sentence)

    # Procesare tampon rămas
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Puncte cheie

  • Fluxul TTS reduce TTFB la câteva sute de milisecunde prin începerea redării înainte de finalizarea generării
  • Formatul pcm este optim pentru flux: nu necesită decodare, redare directă
  • Un tampon de pre-umplere de 2–3 blocuri previne întreruperile la începutul redării
  • Clientul asincron este esențial pentru serverele care gestionează multiple conexiuni simultane
  • Combinarea fluxului LLM și a fluxului TTS permite un agent vocal reactiv fără API-ul Realtime