Garso konvertavimo įrankiai „Python“ kalboje
Šiame puslapyje
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_base64irbase64_to_audioyra dvi esminės funkcijos balso agento eigai- Diskretizavimo dažnio keitimas būtinas, kai jūsų mikrofono dažnis nesutampa su API dažniu
audioopmodulis 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 įdiekiteaudioop-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.