Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Audio-Umwandlungsbibliotheken in Python

Lektion 16 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Eine Audio-Nutzungs-Bibliothek
  2. PCM16 in Base64 und zurück
  3. Abtastfrequenz-Anpassung (Resampling)
  4. Konvertierung zwischen G.711 und PCM
  5. Stille-Erkennung auf Client-Seite
  6. Speichern und Laden von WAV-Dateien
  7. Kernaussagen
  8. Überprüfen Sie Ihr Verständnis

Eine Audio-Nutzungs-Bibliothek

Um eine robuste Voice-Agent-Anwendung zu erstellen, benötigen Sie Hilfsfunktionen, die Audio zwischen verschiedenen Formaten konvertieren. Diese Lektion sammelt die wesentlichen Python-Tools für die Echtzeit-Audioverarbeitung.

PCM16 in Base64 und zurück

Dies sind die beiden Funktionen, die Sie am häufigsten verwenden werden: das Kodieren von aufgezeichnetem Audio in Base64 zum Senden und das Dekodieren von empfangenem Base64-Audio zum Abspielen.

import base64
import numpy as np

def audio_to_base64(audio_data: np.ndarray) -> str:
    """Konvertiert ein float32-Numpy-Array im Bereich [-1, 1] in 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:
    """Konvertiert einen Base64-PCM16-String in ein 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

Einsatz im Voice-Agent-Workflow

import pyaudio
import json

# Mikrofon-Aufnahme → Senden
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
    }))

# Empfangen → Abspielen
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())

Abtastfrequenz-Anpassung (Resampling)

Falls Ihr Mikrofon mit einer anderen Abtastfrequenz aufzeichnet als die API erwartet, müssen Sie die Frequenz anpassen:

from scipy.signal import resample

def resample_audio(
    audio: np.ndarray,
    original_rate: int,
    target_rate: int
) -> np.ndarray:
    """Passt die Abtastfrequenz des Audios von einem Wert auf einen anderen an."""
    if original_rate == target_rate:
        return audio
    num_samples = int(len(audio) * target_rate / original_rate)
    return resample(audio, num_samples)

# Beispiel: Mikrofon bei 44100 Hz → API bei 24000 Hz
audio_44100 = capture_microphone()
audio_24000 = resample_audio(audio_44100, 44100, 24000)
b64 = audio_to_base64(audio_24000)

Konvertierung zwischen G.711 und PCM

Für Telefonintegrationen müssen Sie zwischen G.711 und linearer PCM konvertieren. Achten Sie auf Ihre Python-Version: Das Modul audioop wurde in Version 3.13 aus der Standardbibliothek entfernt. Installieren Sie auf aktuellen Python-Versionen das Paket audioop-lts, das dieselbe Schnittstelle bereitstellt:

import audioop

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

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

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

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

Ein vollständiges Telefon-Relais

Hier ist ein Beispiel für ein Relais zwischen einem G.711-SIP-Stream und der Voice-Agent-API:

async def relay_sip_to_voice_agent(sip_stream, ws):
    """Relaisiert Audio von einem SIP-Anruf an die Voice-Agent-API."""
    async for mulaw_chunk in sip_stream:
        # Konvertiert 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):
    """Relaisiert die Audioantwort der API an den 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)

Stille-Erkennung auf Client-Seite

Wenn Sie die Push-to-Talk-Funktion selbst verwalten oder eine lokale Stille-Erkennung vor dem Senden wünschen, misst diese Funktion die Energie des Signals:

def is_silence(
    audio: np.ndarray,
    threshold: float = 0.01
) -> bool:
    """Ermittelt, ob ein Audio-Segment Stille darstellt."""
    rms = np.sqrt(np.mean(audio ** 2))
    return rms < threshold

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

Speichern und Laden von WAV-Dateien

Für das Debugging und Testen können Sie WAV-Dateien speichern und laden:

import wave

def save_wav(
    filename: str,
    audio: np.ndarray,
    sample_rate: int = 24000
):
    """Speichert ein Numpy-Array als WAV-Datei."""
    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]:
    """Lädt eine WAV-Datei als 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

Kernaussagen

  • audio_to_base64 und base64_to_audio sind die beiden wesentlichen Funktionen für den Voice-Agent-Workflow.
  • Eine Abtastfrequenz-Anpassung (Resampling) ist erforderlich, wenn die Abtastfrequenz Ihres Mikrofons nicht mit der der API übereinstimmt.
  • Das Modul audioop übernimmt die Konvertierungen zwischen G.711 mu-law und A-law; es wurde in Python 3.13 aus der Standardbibliothek entfernt. Installieren Sie auf aktuellen Versionen das Paket audioop-lts von PyPI.
  • Die Stille-Erkennung auf Client-Seite spart Bandbreite, indem nur nützliches Audio gesendet wird.
  • WAV-Hilfsfunktionen erleichtern das Debugging, indem Audio-Streams gespeichert und wiedergegeben werden können.

Überprüfen Sie Ihr Verständnis

WebSocket, VAD, Audio: Der Voice-Agent von Ende zu Ende.

1. Wie wird eine Voice-Agent-Sitzung eingerichtet?

Antwort: Über eine Echtzeit-WebSocket-Verbindung, authentifiziert mit vorübergehenden Tokens (niemals den Hauptschlüssel auf dem Client), und konfiguriert durch session.update, bestätigt durch session.created und session.updated.

2. Was übernimmt VAD?

Antwort: Automatische Spracherkennung: Es ermittelt, wann der Nutzer beginnt und aufhört zu sprechen, sodass der Agent weiß, wann er zuhören und wann antworten soll, ohne dass eine Taste benötigt wird.

3. Wie fließt das Audio?

Antwort: Der Input geht über input_audio_buffer.append aus (mit Buffer-Commit und Clear), und die Antwort kommt als Audio-Events zum Abspielen an, in PCM oder G.711, je nach Kanal.

4. Was ermöglichen Tools und MCP in einer Sprachkonversation?

Antwort: Funktionsaufrufe und integrierte Tools (Web, X, Sammlungen) während des gesprochenen Austauschs: Der Agent recherchiert Dinge und führt Aktionen aus, während er spricht, einschließlich MCP-Ereignisse.

5. Und für die Telefontechnik?

Antwort: SIP und LiveKit mit G.711: Der Voice-Agent schließt sich in das Telefonnetz ein, und die Python-Audio-Konvertierungsbibliotheken überbrücken die Formate.

Eine sichere Sitzung, VAD, gut verwaltete Puffer, Tools in der Sprache: Der vollständige Telefon-Assistent ist greifbar, und dieser Kurs hat Ihnen alle Bausteine geliefert.