Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Streaming af lyd i realtid

Lektion 12 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Streaming af lyd i realtid
  2. Streaming med TTS API’en
  3. Måling af latenstid
  4. Asynkron streaming
  5. Forudfyldning af buffer
  6. Integration med en LLM + TTS-pipeline
  7. Vigtige pointer

Opdatering 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophører med at fungere den 6. januar 2027 (efterfølger: gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af /v1/audio/speech: migration af talesyntese flyttes til Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 26. februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026. Opdateret 3. november 2026: LLM → TTS-pipelinen behandlede tidligere enhver begivenhed, der indeholdt et delta-felt, herunder funktionskaldsargumenter eller resuméer af ræsonnementer; den filtrerer nu strengt efter response.output_text.delta, som er selve svarteksten.

Streaming af lyd i realtid

I en taleagent introducerer ventetid på, at hele lydfilen genereres før afspilning starter, en uacceptabel latenstid. TTS-streaming lader dig starte afspilningen, så snart de første bytes ankommer, hvilket reducerer tiden til første svar til få hundrede millisekunder.

Streaming med TTS API’en

TTS API’en understøtter streaming nativt. I stedet for at vente på den komplette fil, modtager du lyden i bidder:

from openai import OpenAI
import pyaudio

client = OpenAI()

def stream_tts_to_speaker(text: str, voice: str = "alloy"):
    """Generér og afspil lyd i streaming-tilstand."""
    # Initialisér lydafspilleren
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=24000,
        output=True
    )

    try:
        # Opret streaming-svaret
        with client.audio.speech.with_streaming_response.create(
            model="tts-1",
            voice=voice,
            input=text,
            response_format="pcm"  # Rå PCM til direkte afspilning
        ) as response:
            # Læs og afspil bid for bid
            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 er ideelt til streaming, da det ikke kræver afkodning: de rå bytes er klar til afspilning med det samme.

Måling af latenstid

Time to First Byte (TTFB) er den centrale metrik for streaming-ydeevne:

import time

def measure_tts_latency(text: str, voice: str = "alloy") -> dict:
    """Mål TTS-streaming-latenser."""
    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 streaming

Til server-side-applikationer skal du bruge den asynkrone klient:

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_tts_async(text: str, voice: str = "alloy"):
    """Asynkron TTS-streaming til 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)
            # Her ville du sende bitten til klienten via WebSocket
            yield chunk

# Brug 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"
    )

Forudfyldning af buffer

For at sikre jævn afspilning uden huller skal du akkumulere en lille buffer, før du starter:

async def buffered_tts_playback(
    text: str,
    voice: str = "alloy",
    buffer_size: int = 3  # Antal bidder der skal indlæses på forhånd
):
    """TTS-afspilning med en forudfyldt buffer."""
    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 indledende buffer
                    for buffered_chunk in buffer:
                        player.write(buffered_chunk)
                    buffer.clear()
                elif playback_started:
                    player.write(chunk)

        # Afspil resterende bidder
        for remaining in buffer:
            player.write(remaining)

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

Integration med en LLM + TTS-pipeline

I en taleagent, der ikke bruger Realtime API, kan du kombinere LLM-streaming med TTS-streaming:

async def llm_to_tts_pipeline(user_message: str):
    """Pipeline: Streaming LLM → Real-time streaming TTS."""
    # Fase 1: Akkumulér LLM-svar sætning for sætning
    sentence_buffer = ""

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

    for event in stream:
        # Kun svartekst skal tales
        if event.type == "response.output_text.delta":
            sentence_buffer += event.delta

            # Registrér slutningen af en sætning
            if sentence_buffer.rstrip().endswith((".", "!", "?")):
                sentence = sentence_buffer.strip()
                sentence_buffer = ""

                # Fase 2: Stream denne sætning til TTS
                stream_tts_to_speaker(sentence)

    # Behandl resterende buffer
    if sentence_buffer.strip():
        stream_tts_to_speaker(sentence_buffer.strip())

Vigtige pointer

  • TTS-streaming reducerer TTFB til få hundrede millisekunder ved at starte afspilningen, før genereringen er færdig
  • Formatet pcm er optimalt til streaming: ingen afkodning krævet, direkte afspilning
  • En forudfyldt buffer på 2–3 bidder forhindrer huller i starten af afspilningen
  • Den asynkrone klient er essentiel for servere, der håndterer flere samtidige forbindelser
  • Kombination af streaming-LLM og streaming-TTS muliggør en responsiv taleagent uden Realtime API