Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Strimming tal-Awdjo Bidirezzjonali

Lezzjoni 3 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Strimming tal-Awdjo Bidirezzjonali
  2. Format tal-Awdjo PCM16
  3. Tibgħat l-Awdjo: Qbid tal-Mikrofonu
  4. Tirċievi l-Awdjo tat-Tweġiba
  5. Applikazzjoni Sħiħa: Konversazzjoni bil-Vuċi
  6. Punti Ewlenin

Aġġornat fit-2 ta’ Novembru, 2026 — Mudelli tal-awdjo. Diversi mudelli f’dan il-kors huma deprekati: tts-1, tts-1-hd, u gpt-4o-mini-tts se jieqfu jaħdmu fis-6 ta’ Jannar, 2027 (is-sostitut indikat huwa gpt-realtime-2.1-mini, li l-gwida tat-TTS ta’ OpenAI tiddikjara li mhux appoġġjata minn /v1/audio/speech: il-migrazzjoni tas-sinteżi tal-kelma tmur lejn ir-Realtime API); gpt-realtime, gpt-4o-realtime, u mudelli tal-awdjo legacy fl-20 ta’ Jannar, 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe, u /v1/audio/translations fis-26 ta’ Frar, 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Għal-vuċi full-duplex, GPT-Live 1 kien disponibbli fl-API mill-10 ta’ Settembru, 2026.

Strimming tal-Awdjo Bidirezzjonali

L-istrimming tal-awdjo bidirezzjonali huwa l-qalba tar-Realtime API. Inti tibgħat kontinwament biċċiet tal-awdjo mill-mikrofonu, u l-mudell jirritorna kontinwament biċċiet tal-awdjo bħala tweġiba. Dawn iż-żewġ flussi huma indipendenti u jistgħu joperaw simultanjament—li huwa preċiżament dak li jagħmel il-konversazzjoni tħoss naturali.

Format tal-Awdjo PCM16

Ir-Realtime API tuża l-format PCM mono 16-bit b’24 kHz. Dan huwa format mhux ipproċessat u mhux ikkumpressat: kull kampjun huwa numru sħiħ iffirmat ta’ 16-il bit. Din il-għażla tagħti prijorità lil-latenza baxxa fuq l-effiċjenza tal-banda.

24 kHz
Rata tal-kampjunar
16 bit
Fond tal-kampjun
Mono
Kanal wieħed
48 KB/s
Rata tal-bits tal-awdjo mhux ipproċessat

Il-biċċiet tal-awdjo jintbagħtu kodifikati f’Base64 fi ħdan avvenimenti JSON. Kull biċċa tipikament tirrappreżenta bejn 20 u 100 ms ta’ awdjo.

Tibgħat l-Awdjo: Qbid tal-Mikrofonu

Hekk kif taqbad il-mikrofonu u tistrimja l-awdjo:

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):
    """Aqbad il-mikrofonu u ibgħat il-biċċiet lir-Realtime API."""
    loop = asyncio.get_event_loop()
    audio_queue = asyncio.Queue()

    def audio_callback(indata, frames, time_info, status):
        if status:
            print(f"Twissija tal-awdjo: {status}")
        # Ikkonverti għal int16 u żid fil-kju
        pcm_data = (indata[:, 0] * 32767).astype(np.int16)
        loop.call_soon_threadsafe(audio_queue.put_nowait, pcm_data)

    # Ibda l-qbid
    stream = sd.InputStream(
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
        blocksize=CHUNK_SIZE,
        callback=audio_callback
    )

    with stream:
        print("Mikrofonu attiv — kellem issa...")
        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
            }))

Il-Buffer tal-Awdjo fuq is-Server

Il-biċċiet mibgħuta permezz ta’ input_audio_buffer.append jakkumulaw f’buffer fuq is-server. Dan il-buffer jiġi pproċessat b’żewġ modi:

  • Modalità VAD Awtomatika (server_vad): Is-server jinduna meta tieqaf titkellem u jikkummetti l-buffer awtomatikament.
  • Modalità Manwali: Inti tibgħat espliċitament input_audio_buffer.commit biex ttriggera l-ipproċessar.
# Ikkummetti l-buffer tal-awdjo manwalment
await ws.send(json.dumps({
    "type": "input_audio_buffer.commit"
}))

# Jew ċara l-buffer mingħajr ma tipproċessah
await ws.send(json.dumps({
    "type": "input_audio_buffer.clear"
}))

Tirċievi l-Awdjo tat-Tweġiba

It-tweġibiet tal-awdjo jaslu f’biċċiet permezz ta’ avvenimenti response.output_audio.delta. Trid tiddekodjahom u tdoqqhom kontinwament:

import pyaudio

async def play_response_audio(ws):
    """Irċievi u doqq l-awdjo tat-tweġiba."""
    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":
                # Iddekoda l-biċċa tal-awdjo Base64
                audio_bytes = base64.b64decode(event["delta"])
                player.write(audio_bytes)

            elif event["type"] == "response.output_audio.done":
                print("It-tweġiba tal-awdjo ntemmet")

            elif event["type"] == "response.output_audio_transcript.delta":
                # Traskrizzjoni tat-test tat-tweġiba
                print(event["delta"], end="", flush=True)

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

Applikazzjoni Sħiħa: Konversazzjoni bil-Vuċi

Hekk kif tgħaqqad il-qbid u d-daqq għal konversazzjoni sħiħa:

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

    async with websockets.connect(URL, additional_headers=headers) as ws:
        # Stenna għal session.created
        await ws.recv()

        # Ikkonfigura s-sessjoni
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "type": "realtime",
                "output_modalities": ["audio"],
                "instructions": "Inti assistent bil-vuċi. Wieġeb bl-Ingliż.",
                "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

        # Neddi l-qbid u d-daqq parallellament
        await asyncio.gather(
            stream_microphone(ws),
            play_response_audio(ws)
        )

asyncio.run(conversation_vocale())

Ġestjoni ta’ Flussi Konkorrenti

L-isfida bl-istrimming bidirezzjonali hija li qed tibgħat u tirċievi simultanjament fuq l-istess WebSocket. asyncio.gather tniedi ż-żewġ koroutini parallellament, iżda jaqsmu l-istess oġġett WebSocket. Il-librerija websockets timmaniġġja din il-konkorrenza b’mod korrett.

Punti Ewlenin

  • L-awdjo jiġi trażmess bħala PCM mono 16-bit ta’ 24 kHz, kodifikat f’Base64 f’avvenimenti JSON
  • Il-biċċiet huma tipikament bejn 20 u 100 ms ta’ awdjo għal kumpromess tajjeb bejn il-latenza u l-overhead
  • Il-buffer tal-awdjo fuq is-server jakkumula l-biċċiet sakemm jiġi kkommettut (awtomatiku fil-modalità VAD)
  • Id-daqq tat-tweġiba jsir biċċa biċċa permezz ta’ response.output_audio.delta
  • asyncio.gather jippermetti l-qbid u d-daqq simultanji fuq l-istess WebSocket