Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Garso konvertavimo įrankiai „Python“ kalboje

Paskaita 16 iš 16 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Garso įrankių biblioteka
  2. PCM16 į base64 ir atgal
  3. Diskretizavimo dažnio keitimas (Resampling)
  4. Konvertavimas tarp G.711 ir PCM
  5. Tylos aptikimas kliento pusėje
  6. WAV failų įrašymas ir nuskaitymas
  7. Svarbiausi punktai
  8. Patikrinkite savo žinias

Garso įrankių biblioteka

Norint sukurti patikimą balso agento programą, reikia pagalbinių funkcijų, kurios konvertuotų garso įrašus tarp skirtingų formatų. Šioje pamokoje surinkti pagrindiniai „Python“ įrankiai garso apdorojimui realiuoju laiku.

PCM16 į base64 ir atgal

Tai dvi funkcijos, kurias naudosite dažniausiai: užfiksuoto garso kodavimas į base64 siuntimui ir gauto base64 garso dekodavimas atkūrimui.

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

Naudojimas balso agento eigoje

import pyaudio
import json

# Mikrofono įrašymas → siuntimas
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
    }))

# Gavimas → atkūrimas
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())

Diskretizavimo dažnio keitimas (Resampling)

Jei jūsų mikrofonas fiksuoja garso įrašą kitu diskretizavimo dažniu nei tikisi API, turite pakeisti dažnį:

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)

# Pavyzdys: mikrofonas 44100 Hz → API 24000 Hz
audio_44100 = capture_microphone()
audio_24000 = resample_audio(audio_44100, 44100, 24000)
b64 = audio_to_base64(audio_24000)

Konvertavimas tarp G.711 ir PCM

Integruojant telefoniją, reikės konvertuoti tarp G.711 ir linijinio PCM. Atkreipkite dėmesį į savo „Python“ versiją: audioop buvo pašalintas iš standartinės bibliotekos nuo 3.13 versijos. Naujesnėje „Python“ versijoje įdiekite audioop-lts paketą, kuris suteikia tą pačią sąsają:

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)

Pilnas telefono relė

Štai pavyzdys, kaip perduoti garso srautą tarp G.711 SIP srauto ir balso agento API:

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:
        # Konvertuoti 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)

Tylos aptikimas kliento pusėje

Jei patys valdote „paspausk ir kalbėk“ funkciją arba norite aptikti tylą vietoje prieš siųsdami, ši funkcija išmatuoja signalo energiją:

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

# Naudojimas
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
    }))

WAV failų įrašymas ir nuskaitymas

Derinimui ir testavimui galite įrašyti ir nuskaityti WAV failus:

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

Svarbiausi punktai

  • audio_to_base64 ir base64_to_audio yra dvi esminės funkcijos balso agento eigai
  • Diskretizavimo dažnio keitimas būtinas, kai jūsų mikrofono dažnis nesutampa su API dažniu
  • audioop modulis tvarko G.711 mu-law ir A-law konvertavimą; jis buvo pašalintas iš standartinės bibliotekos „Python“ 3.13 versijoje, todėl naujesnėse versijose iš PyPI įdiekite audioop-lts
  • Tylos aptikimas kliento pusėje taupo pralaidumą siunčiant tik naudingą garso informaciją
  • WAV įrankiai palengvina derinimą, leisdamiesi įrašyti ir atkurti garso srautus

Patikrinkite savo žinias

„WebSocket“, VAD, garso įrašai: balso agentas nuo pradžių iki galo.

1. Kaip nustatyti balso agento sesiją?

Atsakymas: Naudodami „WebSocket“ ryšį realiuoju laiku, autentifikavę laikinais žetonais (niekada nenaudokite pagrindinio rakto kliento pusėje), tada sukonfigūravę per session.update ir patvirtinę per session.created bei session.updated.

2. Ką tvarko VAD?

Atsakymas: Automatinį kalbos aptikimą: jis nustato, kada vartotojas pradeda ir baigia kalbėti, kad agentas žinotų, kada klausytis, o kada atsakyti, be jokių mygtukų.

3. Kaip teka garso įrašai?

Atsakymas: Įvestis siunčiama per input_audio_buffer.append (su buferio fiksavimu ir išvalymu), o atsakymas ateina kaip garso įvykiai atkūrimui, PCM arba G.711 formatu, priklausomai nuo kanalo.

4. Ką leidžia daryti įrankiai ir MCP balso pokalbyje?

Atsakymas: Funkcijų kvietimą ir integruotus įrankius (web, X, kolekcijos) kalbėjimo metu: agentas ieško informacijos ir imasi veiksmų kalbėdamas, įskaitant MCP įvykius.

5. O kaip su telefonija?

Atsakymas: SIP ir „LiveKit“ su G.711: balso agentas jungiasi prie telefono tinklo, o „Python“ garso konvertavimo įrankiai sujungia formatus.

Saugi sesija, VAD, tinkamai valdomi buferiai, įrankiai balse: pilnas telefono asistentas yra pasiekiamas, ir šis kursas suteikė jums visas tam reikalingas dalis.