Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Áiseanna tiontaithe fuaime i bPython

Ceacht 16 as 16 Nuashonraithe 30 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Leabharlann áise fuaime
  2. PCM16 go base64 agus ar ais
  3. Athshamplú
  4. Tiontú idir G.711 agus PCM
  5. Brath ciúnais ar thaobh an chliaint
  6. Comhaid WAV a shábháil agus a lódáil
  7. Príomhphointí
  8. Seiceáil do thuiscint

Leabharlann áise fuaime

Chun aip Gníomhaire Gutha láidir a thógáil, teastaíonn feidhmeanna úsáide uait chun fuaim a thiontú idir formáidí. Bailíonn an ceacht seo na huirlisí Python riachtanacha chun próiseáil fuaime i bhfíor-am.

PCM16 go base64 agus ar ais

Seo an dá fheidhm is minice a úsáidfidh tú: fuaim ghabhála a ionchódú i base64 chun í a sheoladh, agus fuaim base64 faighte a dhíchódú chun í a sheinm.

import base64
import numpy as np

def audio_to_base64(audio_data: np.ndarray) -> str:
    """Converts a float32 numpy array in [-1, 1] to base64 PCM16."""
    audio_int16 = (audio_data * 32767).astype(np.int16)
    return base64.b64encode(audio_int16.tobytes()).decode("utf-8")

def base64_to_audio(base64_audio: str) -> np.ndarray:
    """Converts a base64 PCM16 string to a float32 numpy array."""
    audio_bytes = base64.b64decode(base64_audio)
    audio_int16 = np.frombuffer(audio_bytes, dtype=np.int16)
    return audio_int16.astype(np.float32) / 32768.0

Iad a úsáid i sruth an Ghníomhaire Gutha

import pyaudio
import json

# Gabháil micreafóin → seol
def capture_and_send(ws, stream, chunk_size=4096):
    raw_data = stream.read(chunk_size, exception_on_overflow=False)
    audio_array = np.frombuffer(raw_data, dtype=np.int16)
    audio_float = audio_array.astype(np.float32) / 32768.0
    b64 = audio_to_base64(audio_float)

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

# Faigh → seinm
def play_received(player_stream, base64_audio):
    audio_float = base64_to_audio(base64_audio)
    audio_int16 = (audio_float * 32767).astype(np.int16)
    player_stream.write(audio_int16.tobytes())

Athshamplú

Má ghabhann do mhicreafón ag ráta samplála atá difriúil ón ráta a bhfuil súil leis ag an API, ní mór duit athshamplú a dhéanamh:

from scipy.signal import resample

def resample_audio(
    audio: np.ndarray,
    original_rate: int,
    target_rate: int
) -> np.ndarray:
    """Resamples audio from one sample rate to another."""
    if original_rate == target_rate:
        return audio
    num_samples = int(len(audio) * target_rate / original_rate)
    return resample(audio, num_samples)

# Sampla: micreafón ag 44100 Hz → API ag 24000 Hz
audio_44100 = capture_microphone()
audio_24000 = resample_audio(audio_44100, 44100, 24000)
b64 = audio_to_base64(audio_24000)

Tiontú idir G.711 agus PCM

Chun comhtháthú fóin a dhéanamh, beidh ort tiontú idir G.711 agus PCM líneach. Bí ar an airdeall maidir le do leagan Python: baineadh audioop den leabharlann caighdeánach i leagan 3.13. Ar leagan nua-aimseartha de Python, suiteáil an pacáiste audioop-lts, a sholáthraíonn an comhéadan céanna:

import audioop

def pcm_to_mulaw(pcm_data: bytes) -> bytes:
    """Converts PCM16 to G.711 mu-law."""
    return audioop.lin2ulaw(pcm_data, 2)

def mulaw_to_pcm(mulaw_data: bytes) -> bytes:
    """Converts G.711 mu-law to PCM16."""
    return audioop.ulaw2lin(mulaw_data, 2)

def pcm_to_alaw(pcm_data: bytes) -> bytes:
    """Converts PCM16 to G.711 A-law."""
    return audioop.lin2alaw(pcm_data, 2)

def alaw_to_pcm(alaw_data: bytes) -> bytes:
    """Converts G.711 A-law to PCM16."""
    return audioop.alaw2lin(alaw_data, 2)

Seachadadh fóin iomlán

Seo sampla de sheachadadh idir sruth SIP G.711 agus API an Ghníomhaire Gutha:

async def relay_sip_to_voice_agent(sip_stream, ws):
    """Relays audio from a SIP call to the Voice Agent API."""
    async for mulaw_chunk in sip_stream:
        # Tiontaigh mu-law → PCM → base64
        pcm_data = mulaw_to_pcm(mulaw_chunk)
        b64 = base64.b64encode(pcm_data).decode("utf-8")

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

async def relay_voice_agent_to_sip(ws, sip_stream):
    """Relays the API's audio response to the SIP stream."""
    async for message in ws:
        event = json.loads(message)
        if event["type"] == "response.output_audio.delta":
            pcm_data = base64.b64decode(event["delta"])
            mulaw_data = pcm_to_mulaw(pcm_data)
            await sip_stream.send(mulaw_data)

Brath ciúnais ar thaobh an chliaint

Má láimhseálann tú “brú-chun-labhairt” (push-to-talk) tú féin, nó más mian leat brath ciúnais áitiúil sula seolann tú, tomhaiseann an fheidhm seo fuinneamh an chomhartha:

def is_silence(
    audio: np.ndarray,
    threshold: float = 0.01
) -> bool:
    """Detects whether an audio chunk is silence."""
    rms = np.sqrt(np.mean(audio ** 2))
    return rms < threshold

# Úsáid
audio_chunk = capture_microphone()
if not is_silence(audio_chunk, threshold=0.02):
    b64 = audio_to_base64(audio_chunk)
    ws.send(json.dumps({
        "type": "input_audio_buffer.append",
        "audio": b64
    }))

Comhaid WAV a shábháil agus a lódáil

Chun dífhabhtú agus tástála, is féidir leat comhaid WAV a shábháil agus a lódáil:

import wave

def save_wav(
    filename: str,
    audio: np.ndarray,
    sample_rate: int = 24000
):
    """Saves a numpy array as a WAV file."""
    audio_int16 = (audio * 32767).astype(np.int16)
    with wave.open(filename, "wb") as wf:
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(sample_rate)
        wf.writeframes(audio_int16.tobytes())

def load_wav(filename: str) -> tuple[np.ndarray, int]:
    """Loads a WAV file as a float32 numpy array."""
    with wave.open(filename, "rb") as wf:
        sample_rate = wf.getframerate()
        frames = wf.readframes(wf.getnframes())
        audio_int16 = np.frombuffer(frames, dtype=np.int16)
        return audio_int16.astype(np.float32) / 32768.0, sample_rate

Príomhphointí

  • Is iad audio_to_base64 agus base64_to_audio an dá fheidhm riachtanacha do shruth an Ghníomhaire Gutha
  • Teastaíonn athshamplú nuair nach bhfuil ráta samplála do mhicreafóin comhoiriúnach leis an API
  • Déileálann an modúl audioop le tiontaithe G.711 mu-law agus A-law; baineadh den leabharlann caighdeánach é i bPython 3.13, mar sin suiteáil audioop-lts ó PyPI ar leaganacha nua-aimseartha
  • Sábhálann brath ciúnais ar thaobh an chliaint bandaleithead trí fhuaimeanna úsáideacha amháin a sheoladh
  • Déanann áiseanna WAV an dífhabhtú níos fusa trí ligean duit sruthanna fuaime a shábháil agus a athsheinm

Seiceáil do thuiscint

WebSocket, VAD, fuaim: an gníomhaire gutha ó cheann go ceann.

1. Conas a shocraíonn tú seisiún Gníomhaire Gutha?

Freagra: Le nasc WebSocket fíor-ama, fíordheimhnithe le comharthaí sealadacha (ná húsáid an eochair mhór riamh ar an gcliant), ansin cumraithe trí session.update agus deimhnithe ag session.created agus session.updated.

2. Cad a láimhseálann VAD?

Freagra: Brath uathoibríoch cainte: oibríonn sé amach cathain a thosaíonn an t-úsáideoir ag caint agus cathain a stopann sé, ionas go bhfuil a fhios ag an ngníomhaire cathain le héisteacht agus cathain le freagairt, gan aon chnaipe.

3. Conas a shreabhann an fhuaim?

Freagra: Téann an t-ionchur amach trí input_audio_buffer.append (le tiomnú agus glanadh an mhaoláin), agus tagann an fhreagairt mar imeachtaí fuaime le seinm, i PCM nó G.711 ag brath ar an gcainéal.

4. Cad a chuireann uirlisí agus MCP ar chumas i gcomhrá gutha?

Freagra: Glao feidhme agus uirlisí ionsuite (gréasán, X, bailiúcháin) le linn an mhalartaithe labhartha: déanann an gníomhaire taighde ar rudaí agus glacann sé gníomh agus é ag caint, imeachtaí MCP san áireamh.

5. Agus maidir le teileafóine?

Freagra: SIP agus LiveKit le G.711: plugálann an gníomhaire gutha isteach sa líonra fóin, agus déanann na háiseanna tiontaithe fuaime Python droichead idir na formáidí.

Seisiún slán, VAD, maoláin bhainistithe go maith, uirlisí i nguth: tá an cúntóir fóin iomlán laistigh d’fhaid láimhe, agus thug an cúrsa seo gach píosa duit.