Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Reaalajas helivoogedastus

Õppetund 12 / 18 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Reaalajas helivoogedastus
  2. Voogedastus TTS API-ga
  3. Latentsuse mõõtmine
  4. Asünkroonne voogedastus
  5. Eeltäidetud puhver
  6. Integreerimine LLM + TTS töövoogu
  7. Peamised punktid

Uuendus 2. novembril 2026 – Helimudelid. Selles kursuses on mitu mudelit aegunud: tts-1, tts-1-hd ja gpt-4o-mini-tts lõpetavad töö 6. jaanuaril 2027 (järeltulija: gpt-realtime-2.1-mini, mille OpenAI TTS juhend märgib kui mittetoetatud /v1/audio/speech poolt: häälesünteesi migratsioon liigub Realtime API-le); gpt-realtime, gpt-4o-realtime ja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. veebruaril 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täisdupleksse kõne jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026. Uuendatud 3. novembril 2026: LLM → TTS töövoog töötles varem kõiki sündmusi, mis sisaldasid välja delta, sealhulgas funktsioonikutsude argumente või arutluskäigu kokkuvõtteid; nüüd filtreerib see rangelt ainult response.output_text.delta, mis on tegelik vastuse tekst.

Reaalajas helivoogedastus

Hääleagendi puhul toob kogu helifaili genereerimise ootamine enne taasesituse alustamist kaasa vastuvõetamatu latentsuse. TTS-i voogedastus võimaldab sul alustada taasesitust niipea, kui saabuvad esimesed baidid, vähendades esimese vastuseni jõudmise aega mõnele sajale millisekundile.

Voogedastus TTS API-ga

TTS API toetab voogedastust loomupäraselt. Täieliku faili ootamise asemel saad heli tükkidena:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Genereeri ja esita heli voogedastusrežiimis."""
    # Algata helimängija
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Loo voogedastuse vastus
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Toores PCM otseseks taasesituseks
        ) as response:
            # Loe ja esita tükk haaval
            for chunk in response.iter_bytes(chunk_size=4096):
                player.write(chunk)

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

stream_tts_to_speaker("Tere, siin on reaalajas voogedastuse vastus.")

Formaat pcm on voogedastuseks ideaalne, kuna see ei vaja dekodeerimist: toored baidid on koheseks esitamiseks valmis.

Latentsuse mõõtmine

Esimese baidini kuluv aeg (TTFB) on voogedastuse jõudluse võtmemõõdik:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mõõda TTS-i voogedastuse latentsust."""
    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("Tere, kuidas läheb?")
print(f"TTFB: {metrics['ttfb_ms']}ms, Kokku: {metrics['total_ms']}ms")

Asünkroonne voogedastus

Serveripoolsete rakenduste jaoks kasuta asünkroonset klienti:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asünkroonne TTS-i voogedastus serveritele."""
    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)
            # Siin saadaksid tüki kliendile WebSocketi kaudu
            yield chunk

# Kasutamine FastAPI serveris
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"
    )

Eeltäidetud puhver

Sujuva taasesituse tagamiseks ilma katkestusteta kogune väike puhver enne algust:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Eellaaditavate tükkide arv
):
    """TTS-i taasesitus eeltäidetud puhvriga."""
    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
                    # Tühjenda algne puhver
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Esita ülejäänud tükid
        for remaining in buffer:
            player.write(remaining)

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

Integreerimine LLM + TTS töövoogu

Mitte-Realtime hääleagendis saad kombineerida LLM-i voogedastuse TTS-i voogedastusega:

async def llm_to_tts_pipeline(user_message: str):
    """Töövoog: Voogedastav LLM → Reaalajas voogedastav TTS."""
    # Faas 1: Kogu LLM-i vastus lausetena
    sentence_buffer = ""

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

    for event in stream:
        # Rääkida tuleks ainult vastuse teksti
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Tuvasta lause lõpp
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Faas 2: Voogedasta see lause TTS-i
                stream_tts_to_speaker(sentence)

    # Töötle ülejäänud puhver
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Peamised punktid

  • TTS-i voogedastus vähendab TTFB-i mõnele sajale millisekundile, alustades taasesitust enne genereerimise lõppu
  • Formaat pcm on voogedastuseks optimaalne: dekodeerimist pole vaja, otsene taasesitus
  • 2–3 tüki suurune eeltäidetud puhver hoiab ära katkestused taasesituse alguses
  • Asünkroonne klient on hädavajalik serveritele, mis haldavad mitut samaaegset ühendust
  • Voogedastava LLM-i ja voogedastava TTS-i kombineerimine võimaldab luua reageerimisvõimelist hääleagenti ilma Realtime API-t kasutamata