Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Garso srautinis perdavimas realiuoju laiku

Paskaita 12 iš 18 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Garso srautinis perdavimas realiuoju laiku
  2. Srautinis perdavimas naudojant TTS API
  3. Delsos matavimas
  4. Asinchroninis srautinis perdavimas
  5. Išankstinis buferio užpildymas
  6. Integravimas su LLM + TTS grandine
  7. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę: tts-1, tts-1-hd ir gpt-4o-mini-tts nustos veikti 2027 m. sausio 6 d. (įpėdinis: gpt-realtime-2.1-mini, kurio, kaip nurodoma „OpenAI TTS“ gide, nepalaiko /v1/audio/speech: balso sintezės migracija perkeliama į „Realtime API“); gpt-realtime, gpt-4o-realtime ir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ir /v1/audio/translations nustos veikti 2027 m. vasario 26 d. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Visapusiškam dvipusiam balsui „GPT-Live 1“ API yra prieinamas nuo 2026 m. rugsėjo 10 d. Atnaujinta 2026 m. lapkričio 3 d.: Anksčiau LLM → TTS grandinė apdorodavo bet kokį įvykį, turintį delta lauką, įskaitant funkcijų kvietimų argumentus arba samprotavimų santraukas; dabar ji griežtai filtruoja tik response.output_text.delta, tai yra tikrąjį atsakymo tekstą.

Garso srautinis perdavimas realiuoju laiku

Balso agente laukti, kol sugeneruojamas visas garso failas prieš pradedant jį groti, sukelia nepriimtiną delsą. TTS srautinis perdavimas leidžia pradėti groti vos gavus pirmuosius baitus, taip sutrumpinant laiką iki pirmojo atsakymo iki kelių šimtų milisekundžių.

Srautinis perdavimas naudojant TTS API

TTS API natūraliai palaiko srautinį perdavimą. Užuot laukęs viso failo, gauni garso duomenis gabalėliais:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generuoti ir groti garso srautiniu režimu."""
    # Inicijuoti garso grotuvą
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Sukurti srautinį atsakymą
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Žalias PCM tiesioginiam grojimui
        ) as response:
            # Skaityti ir groti gabalėlis po gabalėlio
            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.")

pcm formatas idealiai tinka srautiniam perdavimui, nes jam nereikia dekoduoti: žali baitai yra paruošti nedelsiant groti.

Delsos matavimas

Laikas iki pirmojo baito (TTFB) yra pagrindinis srautinio perdavimo našumo rodiklis:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Išmatuoti TTS srautinio perdavimo delsą."""
    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")

Asinchroninis srautinis perdavimas

Serverio pusės programoms naudok asinchroninį klientą:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asinchroninis TTS srautinis perdavimas serveriams."""
    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)
            # Čia siųstum gabalėlį klientui per „WebSocket“
            yield chunk

# Naudojimas „FastAPI“ serveryje
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"
    )

Išankstinis buferio užpildymas

Kad užtikrintum sklandų grojimą be trikdžių, prieš pradėdamas sukaupk nedidelį buferį:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Iš anksto įkeliamų gabalėlių skaičius
):
    """TTS grojimas su išankstinio užpildymo buferiu."""
    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
                    # Išsiųsti pradinį buferį
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Sugroti likusius gabalėlius
        for remaining in buffer:
            player.write(remaining)

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

Integravimas su LLM + TTS grandine

Nerealiojo laiko balso agente gali derinti LLM srautinį perdavimą su TTS srautiniu perdavimu:

async def llm_to_tts_pipeline(user_message: str):
    """Grandinė: Srautinis LLM → Realiojo laiko srautinis TTS."""
    # 1 etapas: Kaupti LLM atsakymą pagal sakinius
    sentence_buffer = ""

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

    for event in stream:
        # Tarti reikia tik atsakymo tekstą
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Aptikti sakinio pabaigą
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # 2 etapas: Siųsti šį sakinį į TTS srautu
                stream_tts_to_speaker(sentence)

    # Apdoroti likusį buferį
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Svarbiausi punktai

  • TTS srautinis perdavimas sutrumpina TTFB iki kelių šimtų milisekundžių, pradėdamas groti prieš baigiant generavimą
  • pcm formatas yra optimalus srautiniam perdavimui: nereikia dekoduoti, galima groti tiesiogiai
  • 2–3 gabalėlių išankstinio užpildymo buferis apsaugo nuo trikdžių grojimo pradžioje
  • Asinchroninis klientas yra būtinas serveriams, tvarkantiems kelis vienuolinius ryšius
  • Srautinio LLM ir srautinio TTS derinimas leidžia sukurti reaguojaantį balso agentą nenaudojant „Realtime API“