Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Strömning av ljud i realtid

Lektion 12 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Strömning av ljud i realtid
  2. Strömning med TTS API
  3. Mätning av latens
  4. Asynkron strömning
  5. Förifyllning av buffert
  6. Integrering med en LLM + TTS-pipeline
  7. Viktiga punkter

Uppdatering 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts slutar fungera den 6 januari 2027 (efträdare: gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av /v1/audio/speech: migreringen av röstsyntes flyttas till Realtime API); gpt-realtime, gpt-4o-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 26 februari 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). För full duplex-röst har GPT-Live 1 funnits tillgängligt i API:t sedan den 10 september 2026. Uppdaterad 3 november 2026: Pipelinen LLM → TTS bearbetade tidigare alla händelser som innehöll ett fält delta, inklusive funktionsanropsargument eller resonemangssammanfattningar; den filtrerar nu strikt efter response.output_text.delta, vilket är den faktiska svarstexten.

Strömning av ljud i realtid

I en röstagent introducerar väntan på att hela ljudfilen ska genereras innan uppspelningen startar en oacceptabel latens. Med TTS-strömning kan du påbörja uppspelningen så snart de första byten anländer, vilket minskar tiden till första svar till några hundra millisekunder.

Strömning med TTS API

TTS API stöder strömning inbyggt. Istället för att vänta på hela filen får du ljudet i bitar:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generera och spela upp ljud i strömningsläge."""
    # Initiera ljudspelaren
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Skapa strömningssvaret
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Rå PCM för direkt uppspelning
        ) as response:
            # Läs och spela upp bit för bit
            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.")

Formatet pcm är idealiskt för strömning eftersom det inte kräver någon avkodning: de råa byten är redo att spelas upp omedelbart.

Mätning av latens

Time to First Byte (TTFB) är nyckelmåtten för strömningsprestanda:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mät TTS-strömningslatenser."""
    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")

Asynkron strömning

För serverapplikationer bör du använda den asynkrona klienten:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asynkron TTS-strömning för servrar."""
    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)
            # Här skulle du skicka biten till klienten via WebSocket
            yield chunk

# Användning i en FastAPI-server
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"
    )

Förifyllning av buffert

För att säkerställa en jämn uppspelning utan avbrott bör du samla en liten buffert innan du startar:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Antal bitar att förinläsa
):
    """TTS-uppspelning med förifylld buffert."""
    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öm den initiala bufferten
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Spela upp återstående bitar
        for remaining in buffer:
            player.write(remaining)

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

Integrering med en LLM + TTS-pipeline

I en röstagent som inte använder Realtime API kan du kombinera LLM-strömning med TTS-strömning:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Strömmande LLM → Strömmande TTS i realtid."""
    # Fas 1: Ackumulera LLM-svar mening för mening
    sentence_buffer = ""

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

    for event in stream:
        # Endast svarstext ska talas
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Upptäck slutet på en mening
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fas 2: Strömma denna mening till TTS
                stream_tts_to_speaker(sentence)

    # Bearbeta återstående buffert
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Viktiga punkter

  • TTS-strömning minskar TTFB till några hundra millisekunder genom att starta uppspelningen innan genereringen är klar
  • Formatet pcm är optimalt för strömning: ingen avkodning krävs, direkt uppspelning
  • En förifylld buffert på 2–3 bitar förhindrar avbrott i början av uppspelningen
  • Den asynkrona klienten är avgörande för servrar som hanterar flera samtidiga anslutningar
  • Kombinationen av strömmande LLM och strömmande TTS möjliggör en responsiv röstagent utan Realtime API