Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Strujanje zvuka u stvarnom vremenu

Lekcija 12 od 18 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Strujanje zvuka u stvarnom vremenu
  2. Strujanje s TTS API-jem
  3. Mjerenje latencije
  4. Asinkrono strujanje
  5. Predpunjenje međuspremnika (Pre-fill buffer)
  6. Integracija s LLM + TTS pipelineom
  7. Ključne točke

Ažuriranje 2. studenoga 2026. — Zvučni modeli. Nekoliko modela u ovom tečaju je zastarjelo: tts-1, tts-1-hd i gpt-4o-mini-tts prestat će raditi 6. siječnja 2027. (nasljednik: gpt-realtime-2.1-mini, za koji OpenAI TTS vodič navodi da nije podržan od strane /v1/audio/speech: migracija sinteze glasa prelazi na Realtime API); gpt-realtime, gpt-4o-realtime i stariji zvučni modeli 20. siječnja 2027. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26. veljače 2027. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za full-duplex glas, GPT-Live 1 dostupan je u API-ju od 10. rujna 2026. Ažurirano 3. studenoga 2026.: LLM → TTS pipeline prethodno je obrađivao bilo koji događaj koji sadrži polje delta, uključujući argumente poziva funkcija ili sažetke rezoniranja; sada strogo filtrira samo response.output_text.delta, odnosno stvarni tekst odgovora.

Strujanje zvuka u stvarnom vremenu

Kod glasovnog agenta, čekanje da se cijela zvučna datoteka generira prije početka reprodukcije uvodi neprihvatljivo kašnjenje. Strujanje TTS-a omogućuje ti početak reprodukcije čim stignu prvi bajtovi, smanjujući vrijeme do prvog odgovora na nekoliko stotina milisekundi.

Strujanje s TTS API-jem

TTS API izvorno podržava strujanje. Umjesto čekanja kompletne datoteke, audio primaš u komadima (chunkovima):

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generiraj i reproduciraj audio u načinu strujanja."""
    # Inicijaliziraj audio player
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Kreiraj odgovor za strujanje
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Sirovi PCM za izravnu reprodukciju
        ) as response:
            # Čitaj i reproduciraj komad po komad
            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.")

Format pcm idealan je za strujanje jer ne zahtijeva dekodiranje: sirovi bajtovi spremni su za trenutnu reprodukciju.

Mjerenje latencije

Vrijeme do prvog bajta (TTFB) ključna je metrika za performanse strujanja:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Izmjeri latencije TTS strujanja."""
    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")

Asinkrono strujanje

Za aplikacije na strani poslužitelja koristi asinkroni klijent:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asinkrono TTS strujanje za poslužitelje."""
    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)
            # Ovdje bi poslao komad klijentu putem WebSocket-a
            yield chunk

# Upotreba u FastAPI poslužitelju
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"
    )

Predpunjenje međuspremnika (Pre-fill buffer)

Kako bi osigurao glatku reprodukciju bez prekida, akumuliraj mali međuspremnik prije početka:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Broj komada za predučitavanje
):
    """TTS reprodukcija s međuspremnikom za predpunjenje."""
    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
                    # Isprazni početni međuspremnik
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Reproduciraj preostale komade
        for remaining in buffer:
            player.write(remaining)

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

Integracija s LLM + TTS pipelineom

U glasovnom agentu koji ne koristi Realtime API, možeš kombinirati LLM strujanje s TTS strujanjem:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Strujanje LLM → Strujanje TTS u stvarnom vremenu."""
    # Faza 1: Akumuliraj LLM odgovor po rečenicama
    sentence_buffer = ""

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

    for event in stream:
        # Govoriti treba samo tekst odgovora
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Detektiraj kraj rečenice
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Faza 2: Strujaj ovu rečenicu u TTS
                stream_tts_to_speaker(sentence)

    # Obradi preostali međuspremnik
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Ključne točke

  • TTS strujanje smanjuje TTFB na nekoliko stotina milisekundi pokretanjem reprodukcije prije završetka generiranja
  • Format pcm optimalan je za strujanje: nije potrebno dekodiranje, izravna reprodukcija
  • Međuspremnik za predpunjenje od 2–3 komada sprječava prekide na početku reprodukcije
  • Asinkroni klijent ključan je za poslužitelje koji obrađuju više istovremenih veza
  • Kombinacija strujanja LLM-a i strujanja TTS-a omogućuje responzivan glasovni agent bez korištenja Realtime API-ja