Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Verktyg för ljudkonvertering i Python

Lektion 16 av 16 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Ett bibliotek för ljudverktyg
  2. PCM16 till base64 och tillbaka
  3. Omavsampling (Resampling)
  4. Konvertering mellan G.711 och PCM
  5. Tystnadsdetektering på klientsidan
  6. Spara och läsa WAV-filer
  7. Viktiga punkter
  8. Testa din förståelse

Ett bibliotek för ljudverktyg

För att bygga en robust Voice Agent-app behöver du hjälpfunktioner som konverterar ljud mellan olika format. Den här lektionen samlar de viktigaste Python-verktygen för ljudbehandling i realtid.

PCM16 till base64 och tillbaka

Detta är de två funktioner du kommer att använda mest: kodning av inspelat ljud till base64 för att skicka det, och avkodning av mottaget base64-ljud för att spela upp det.

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

Användning i Voice Agent-flödet

import pyaudio
import json

# Mic capture → send
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
    }))

# Receive → play
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())

Omavsampling (Resampling)

Om din mikrofon spelar in med en annan samplingsfrekvens än vad API:t förväntar sig måste du utföra omavsampling:

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)

# Example: mic at 44100 Hz → API at 24000 Hz
audio_44100 = capture_microphone()
audio_24000 = resample_audio(audio_44100, 44100, 24000)
b64 = audio_to_base64(audio_24000)

Konvertering mellan G.711 och PCM

För telefonintegrationer behöver du konvertera mellan G.711 och linjär PCM. Håll koll på din Python-version: audioop togs bort från standardbiblioteket i version 3.13. På nyare Python-installationer installerar du paketet audioop-lts, som tillhandahåller samma gränssnitt:

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)

En komplett telefonrelä

Här är ett exempel på en reläfunktion mellan en G.711 SIP-ström och Voice Agent API:t:

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

Tystnadsdetektering på klientsidan

Om du hanterar push-to-talk själv, eller vill ha lokal tystnadsdetektering innan sändning, mäter denna funktion signalens energi:

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

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

Spara och läsa WAV-filer

För felsökning och testning kan du spara och läsa WAV-filer:

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

Viktiga punkter

  • audio_to_base64 och base64_to_audio är de två avgörande funktionerna för Voice Agent-flödet
  • Omavsampling krävs när din mikrofons samplingsfrekvens inte matchar API:ts
  • Modulen audioop hanterar konverteringar för G.711 mu-law och A-law; den togs bort från standardbiblioteket i Python 3.13, så installera audioop-lts från PyPI på nyare versioner
  • Tystnadsdetektering på klientsidan sparar bandbredd genom att endast skicka användbart ljud
  • WAV-verktyg underlättar felsökning genom att låta dig spara och spela upp ljudströmmar

Testa din förståelse

WebSocket, VAD, ljud: voice agentn från början till slut.

1. Hur ställer du in en Voice Agent-session?

Svar: Med en WebSocket-anslutning i realtid, autentiserad med tillfälliga token (aldrig huvudnyckeln på klienten), konfigurerad via session.update och bekräftad av session.created och session.updated.

2. Vad hanterar VAD?

Svar: Automatisk taldetektering: den avgör när användaren börjar och slutar tala, så att agenten vet när den ska lyssna och när den ska svara, utan någon knapp.

3. Hur flödar ljudet?

Svar: Inmatning skickas via input_audio_buffer.append (med buffer commit och clear), och svaret anländer som ljudhändelser för uppspelning, i PCM eller G.711 beroende på kanal.

4. Vad möjliggör verktyg och MCP i en röstsamtal?

Svar: Funktionsanrop och inbyggda verktyg (webb, X, samlingar) under det talade utbytet: agenten slår upp saker och vidtar åtgärder medan den pratar, inklusive MCP-händelser.

5. Och för telefoni?

Svar: SIP och LiveKit med G.711: voice agentn kopplas in i telefonnätverket, och Python-verktygen för ljudkonvertering bryggar formaten.

En säker session, VAD, välhanterade buffertar, verktyg i röst: den kompletta telefonassistenten är inom räckhåll, och den här kursen har gett dig alla delar.