Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Lydstreaming i begge retninger

Lektion 3 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Lydstreaming i begge retninger
  2. PCM16-lydformat
  3. Sending af lyd: Mikrofonoptagelse
  4. Modtagelse af svarlyd
  5. Komplet applikation: Talesamtale
  6. Vigtige pointer

Opdateret 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 (den angivne erstatning er gpt-realtime-2.1-mini, hvilket 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-dupleks tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.

Lydstreaming i begge retninger

Lydstreaming i begge retninger er kernen i Realtime API. Du sender løbende lydbidder fra mikrofonen, og modellen returnerer løbende svarlydbidder. Disse to streams er uafhængige og kan køre samtidigt – hvilket er det, der får samtalen til at føles naturlig.

PCM16-lydformat

Realtime API bruger formatet 24 kHz mono 16-bit PCM. Dette er et rått, ukomprimeret format: hver prøve er et 16-bit heltal med fortegn. Dette valg prioriterer lav latens frem for båndbreddeeffektivitet.

24 kHz
Samplingsfrekvens
16 bit
Prøvedybde
Mono
Enkel kanal
48 KB/s
Rå lydbithastighed

Lydbidder sendes Base64-kodet inden for JSON-events. Hver bid repræsenterer typisk 20 til 100 ms lyd.

Sending af lyd: Mikrofonoptagelse

Sådan optager du fra mikrofonen og streamer lyden:

import asyncio
import sounddevice as sd
import numpy as np
import base64
import json

SAMPLE_RATE = 24000
CHUNK_DURATION_MS = 100
CHUNK_SIZE = int(SAMPLE_RATE * CHUNK_DURATION_MS / 1000)

async def stream_microphone(ws):
    """Optag fra mikrofonen og send bidder til Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Audio warning: {status}")
        # Konverter til int16 og sæt i kø
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Start optagelse
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofon aktiv — tal nu...")
        while True:
            pcm_data = await audio_queue.get()
            audio_b64 = base64.b64encode(pcm_data.tobytes()).decode("utf-8")

            await ws.send(json.dumps({
                "type": "input_audio_buffer.append",
                "audio": audio_b64
            }))

Lydbufferen på serversiden

Bidder sendt via input_audio_buffer.append akkumuleres i en buffer på serveren. Denne buffer behandles på to måder:

  • Automatisk VAD-tilstand (server_vad): Serveren registrerer, når du holder op med at tale, og commit’er automatisk bufferen.
  • Manuel tilstand: Du sender eksplicit input_audio_buffer.commit for at udløse behandlingen.
# Commit lydbufferen manuelt
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Eller ryd bufferen uden at behandle den
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Modtagelse af svarlyd

Lydsvar ankommer i bidder via response.output_audio.delta-events. Du skal dekode og afspille dem løbende:

import pyaudio

async def play_response_audio(ws):
    """Modtag og afspil svarlyd."""
    pa = pyaudio.PyAudio()
    player = pa.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=SAMPLE_RATE,
        output=True,
        frames_per_buffer=CHUNK_SIZE
    )

    try:
        async for raw_message in ws:
            event = json.loads(raw_message)

            if event["type"] == "response.output_audio.delta":
                # Dekoder Base64-lydbidden
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Lydsvaret er afsluttet")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Teksttransskription af svaret
                print(event["delta"], end="", flush=True)

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

Komplet applikation: Talesamtale

Sådan samler du optagelse og afspilning til en fuld samtale:

async def conversation_vocale():
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Vent på session.created
        await ws.recv()

        # Konfigurer sessionen
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "You are a voice assistant. Respond in English.",
                "audio": {
                    "input": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 700
                        }
                    },
                    "output": {
                        "format": {"type": "audio/pcm", "rate": 24000},
                        "voice": "marin"
                    }
                }
            }
        }))
        await ws.recv()  # session.updated

        # Start optagelse og afspilning parallelt
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Håndtering af samtidige streams

Udfordringen ved streaming i begge retninger er, at du sender og modtager samtidigt på den samme WebSocket. asyncio.gather starter begge coroutines parallelt, men de deler det samme WebSocket-objekt. Biblioteket websockets håndterer denne samtidighed korrekt.

Vigtige pointer

  • Lyd overføres som 24 kHz mono 16-bit PCM, Base64-kodet i JSON-events
  • Bidder er typisk på 20 til 100 ms lyd for en god balance mellem latens og overhead
  • Lydbufferen på serversiden akkumulerer bidder indtil commit (automatisk i VAD-tilstand)
  • Afspilning af svar sker bid-for-bid via response.output_audio.delta
  • asyncio.gather muliggør samtidig optagelse og afspilning på den samme WebSocket