Áiseanna tiontaithe fuaime i bPython
Ar an leathanach seo
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_base64agusbase64_to_audioan 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
audioople tiontaithe G.711 mu-law agus A-law; baineadh den leabharlann caighdeánach é i bPython 3.13, mar sin suiteáilaudioop-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.