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

Strömning av ljud i båda riktningar

Lektion 3 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Strömning av ljud i båda riktningar
  2. Ljudformatet PCM16
  3. Skicka ljud: Mikrofoninfångning
  4. Ta emot svarsljud
  5. Kompletta applikationen: Röstkonversation
  6. Viktiga punkter

Uppdaterat 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 (ersättaren anges som gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av /v1/audio/speech: migreringen av talgenerering 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änglig i API:t sedan den 10 september 2026.

Strömning av ljud i båda riktningar

Strömning av ljud i båda riktningar är kärnan i Realtime API. Du skickar kontinuerligt ljudbitar från mikrofonen, och modellen returnerar kontinuerligt svarsbitar i ljudformat. Dessa två strömmar är oberoende och kan köras samtidigt – vilket är det som gör samtalet naturligt.

Ljudformatet PCM16

Realtime API använder formatet 24 kHz mono 16-bitars PCM. Detta är ett rått, okomprimerat format: varje sample är ett 16-bitars signerat heltal. Valet prioriterar låg latens framför bandbreddseffektivitet.

24 kHz
Samplingsfrekvens
16 bit
Sampledjup
Mono
En kanal
48 KB/s
Rå ljudbitrate

Ljudbitar skickas Base64-kodade inom JSON-händelser. Varje bit representerar vanligtvis 20 till 100 ms ljud.

Skicka ljud: Mikrofoninfångning

Så här fångar du mikrofonen och strömmar ljudet:

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):
    """Fånga mikrofonen och skicka bitar till Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Ljudvarning: {status}")
        # Konvertera till int16 och lägg i kö
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Starta infångning
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofon aktiv — prata 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
            }))

Ljudbufferten på serversidan

Bitar som skickas via input_audio_buffer.append ackumuleras i en buffert på servern. Denna buffert bearbetas på två sätt:

  • Automatiskt VAD-läge (server_vad): Servern upptäcker när du slutar prata och bekräftar (commits) bufferten automatiskt.
  • Manuellt läge: Du skickar explicit input_audio_buffer.commit för att utlösa bearbetning.
# Bekräfta ljudbufferten manuellt
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Eller töm bufferten utan att bearbeta den
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Ta emot svarsljud

Ljudsvar anländer i bitar via händelserna response.output_audio.delta. Du måste avkoda och spela upp dem kontinuerligt:

import pyaudio

async def play_response_audio(ws):
    """Ta emot och spela upp svarsljud."""
    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":
                # Avkoda Base64-ljudbiten
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("Ljudsvar avslutat")

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

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

Kompletta applikationen: Röstkonversation

Så här sätter du ihop infångning och uppspelning för en hel konversation:

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

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

        # Konfigurera sessionen
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "Du är en röstassistent. Svara på engelska.",
                "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

        # Starta infångning och uppspelning parallellt
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Hantera samtidiga strömmar

Utmaningen med strömning i båda riktningar är att du skickar och tar emot samtidigt över samma WebSocket. asyncio.gather startar båda korutinerna parallellt, men de delar samma WebSocket-objekt. Biblioteket websockets hanterar denna samtidighet korrekt.

Viktiga punkter

  • Ljud överförs som 24 kHz mono 16-bitars PCM, Base64-kodat i JSON-händelser
  • Bitar är vanligtvis 20 till 100 ms ljud för en bra balans mellan latens och overhead
  • Ljudbufferten på serversidan ackumulerar bitar fram till bekräftelse (automatiskt i VAD-läge)
  • Uppspelning av svar sker bit för bit via response.output_audio.delta
  • asyncio.gather möjliggör samtidig infångning och uppspelning över samma WebSocket