Whisper Audioanforderungen: Vollständiger Leitfaden zu unterstützten Formaten und Spezifikationen

---

Unterstützte Audioformate

Audioformate

Format	Erweiterung	Hinweise
WAV	.wav	✅ Bevorzugt, verlustfrei
MP3	.mp3	✅ Häufigstes Format, weit verbreitet
FLAC	.flac	✅ Verlustfrei, gute Kompression
M4A	.m4a	✅ Apple-Format, AAC-Codec
AAC	.aac	✅ Hochwertige Kompression
OGG	.ogg	✅ Open-Source-Format
OPUS	.opus	✅ Geringe Latenz, webfreundlich
WMA	.wma	⚠️ Weniger verbreitet
AMR	.amr	⚠️ Geringe Qualität, Telefonaufnahmen

Videoformate (Audioextraktion)

Format	Erweiterung	Hinweise
MP4	.mp4	✅ Häufigstes Videoformat
AVI	.avi	✅ Älteres Format, weiterhin unterstützt
MKV	.mkv	✅ Containerformat
MOV	.mov	✅ QuickTime-Format
WebM	.webm	✅ Webvideoformat
FLV	.flv	⚠️ Legacy-Flash-Format

---

Abtastraten-Anforderungen

Optimale Abtastrate: 16 kHz

Unterstützte Abtastraten

Eingabe-Abtastrate	Whisper-Verarbeitung	Empfehlung
8 kHz	Resampling auf 16 kHz	✅ Telefonate, akzeptabel
16 kHz	Direkt verwendet	✅ Optimal, kein Resampling
22,05 kHz	Resampling auf 16 kHz	✅ Gute Qualität
44,1 kHz	Resampling auf 16 kHz	✅ CD-Qualität, in Ordnung
48 kHz	Resampling auf 16 kHz	✅ Professionelles Audio, in Ordnung
96 kHz	Resampling auf 16 kHz	⚠️ Unnötig, größere Dateien

Bewährte Methode

# Convert audio to 16 kHz before processing (optional optimization)
import ffmpeg

def convert_to_16khz(input_file, output_file):
    stream = ffmpeg.input(input_file)
    stream = ffmpeg.output(
        stream,
        output_file,
        acodec='pcm_s16le',
        ac=1,  # Mono
        ar=16000  # 16 kHz
    )
    ffmpeg.run(stream, overwrite_output=True)

---

Anforderungen an die Bittiefe

Unterstützte Bittiefen

Bittiefe	Status	Hinweise
8-Bit	✅ Unterstützt	Geringe Qualität, nicht empfohlen
16-Bit	✅ Empfohlen	Standard, ausreichend
24-Bit	✅ Unterstützt	Professionell, größere Dateien
32-Bit Float	✅ Unterstützt	Studioqualität, übertrieben

---

Kanalkonfiguration: Mono vs. Stereo

Mono (empfohlen)

• Kleinere Dateigröße
• Schnellere Verarbeitung
• Keine Kanalmischung nötig
• Optimal für Einzelsprecher-Inhalte

• Aufnahmen mit einem Sprecher
• Telefonate
• Podcasts mit einem Host
• Die meisten Transkriptionsaufgaben

Stereo (unterstützt)

• Sprecher auf getrennten Kanälen (selten)
• Originalaufnahme ist Stereo (Umwandlung automatisch)

import ffmpeg

# Convert stereo to mono
stream = ffmpeg.input('stereo_audio.wav')
stream = ffmpeg.output(
    stream,
    'mono_audio.wav',
    ac=1  # Mono channel
)
ffmpeg.run(stream, overwrite_output=True)

---

Dateigrößenlimits

Praktische Grenzen

Dateigröße	Verarbeitungszeit	Empfehlung
< 10 MB	Sekunden	✅ Ideal
10–100 MB	Minuten	✅ Gut
100–500 MB	10–30 Minuten	⚠️ Chunking erwägen
> 500 MB	30+ Minuten	⚠️ Chunking erforderlich

Speicherüberlegungen

• Base-Modell: ~1–2 GB VRAM
• Small-Modell: ~2–3 GB VRAM
• Medium-Modell: ~5–6 GB VRAM
• Large-Modell: ~10–12 GB VRAM

---

Dauerlimits

Empfohlene Dauer

Dauer	Status	Hinweise
< 30 Minuten	✅ Optimal	Direkt verarbeiten
30–60 Minuten	✅ Gut	Chunking kann nötig sein
1–2 Stunden	⚠️ Chunking empfohlen	Bessere Genauigkeit mit Chunks
> 2 Stunden	⚠️ Chunking erforderlich	Für Stabilität nötig

Warum langes Audio chunken?

1. Speichergrenzen: Verhindert Out-of-Memory-Fehler
2. Bessere Genauigkeit: Kleinere Chunks behalten Kontext besser
3. Schnellere Verarbeitung: Parallele Verarbeitung möglich
4. Fehlerbehebung: Fällt ein Chunk aus, gelingen andere

# Split long audio into 30-60 second chunks with 5-10 second overlap
def chunk_audio(audio_path, chunk_length=60, overlap=5):
    # Implementation: split audio into segments
    # Process each chunk separately
    # Merge results with timestamps
    pass

---

Audioqualitätsanforderungen

Mindestqualität

Faktor	Minimum	Optimal
Signal-Rausch-Verhältnis	> 10 dB	> 20 dB
Bitrate (MP3)	≥ 64 kbps	≥ 128 kbps
Pegel	Hörbar	Normalisiert auf -3 dB
Hintergrundgeräusch	Minimal	Keines
Echo/Nachhall	Minimal	Keines

Qualitäts-Checkliste

• ✅ Klare Sprache: Sprecher sind gut verständlich
• ✅ Wenig Rauschen: Hintergrund überlagert die Sprache nicht
• ✅ Konstanter Pegel: Keine plötzlichen Lautstärkesprünge
• ✅ Kein Clipping: Keine Verzerrung oder Übersteuerung
• ✅ Gutes Mikrofon: Qualitativ hochwertige Aufnahme

---

Codec-Anforderungen

Empfohlene Codecs

Codec	Format	Qualität	Empfehlung
PCM	WAV	Verlustfrei	✅ Am besten für Genauigkeit
FLAC	FLAC	Verlustfrei	✅ Hervorragend, komprimiert
AAC	M4A, MP4	Hochwertig	✅ Sehr gut
MP3	MP3	Lossy	✅ Gut bei ≥128 kbps
OGG Vorbis	OGG	Lossy	✅ Gute Qualität
OPUS	OPUS	Lossy	✅ Gut, geringe Latenz

Codec-Bewährte Methoden

• PCM (WAV) oder FLAC (verlustfrei)

• AAC oder MP3 bei ≥128 kbps (sehr gute Ergebnisse)

• Sehr niedrige MP3-Bitrate (< 64 kbps)
• Stark komprimierte Formate
• Telefon-Codecs (AMR, G.711) außer wenn nötig

---

Empfehlungen zur Audiovorverarbeitung

Vor der Transkription

1. Lautstärke normalisieren

import numpy as np
from scipy.io import wavfile

def normalize_audio(audio_path, output_path, target_dB=-3.0):
    sr, audio = wavfile.read(audio_path)
    audio = audio.astype(np.float32)
    
    # Normalize to target dB
    max_val = np.max(np.abs(audio))
    target_linear = 10 ** (target_dB / 20)
    audio = audio * (target_linear / max_val)
    
    # Clip to prevent overflow
    audio = np.clip(audio, -1.0, 1.0)
    
    wavfile.write(output_path, sr, (audio * 32767).astype(np.int16))

2. Stille entfernen

# Remove leading/trailing silence
# Helps with processing time and accuracy

3. Rauschreduktion (optional)

# Use noise reduction libraries
# librosa, noisereduce, or specialized tools
# Only if background noise is significant

4. Auf 16 kHz resampeln (optional)

import ffmpeg

stream = ffmpeg.input('input.wav')
stream = ffmpeg.output(
    stream,
    'output_16k.wav',
    ar=16000  # Resample to 16 kHz
)
ffmpeg.run(stream, overwrite_output=True)

---

Häufige Audio-Probleme und Lösungen

Problem 1: Sehr niedrige Abtastrate (8 kHz)

• Whisper Medium- oder Large-Modell (besser bei niedrigen Abtastraten)
• Hochsampeln auf 16 kHz (stellt Qualität nicht wieder her, hilft der Verarbeitung)

Problem 2: Stereo mit verschiedenen Sprechern

# Extract each channel separately
import torchaudio

audio, sr = torchaudio.load('stereo.wav')
speaker1 = audio[0]  # Left channel
speaker2 = audio[1]  # Right channel

# Transcribe each separately
result1 = model.transcribe(speaker1)
result2 = model.transcribe(speaker2)

Problem 3: MP3 mit variabler Bitrate

• In konstante Bitrate (CBR) oder WAV konvertieren
• Whisper verarbeitet VBR in der Regel gut, CBR ist vorhersehbarer

Problem 4: Beschädigte Audiodateien

# Re-encode the file
import ffmpeg

stream = ffmpeg.input('corrupted.mp3')
stream = ffmpeg.output(
    stream,
    'fixed.wav',
    acodec='pcm_s16le'
)
ffmpeg.run(stream, overwrite_output=True)

Problem 5: Sehr lange Audiodateien

• In Chunks von 30–60 Sekunden aufteilen
• Chunks nacheinander oder parallel verarbeiten
• Ergebnisse mit Zeitstempeln zusammenführen

---

Format-spezifische Empfehlungen

Für Telefonate

Parameter	Wert	Grund
Abtastrate	8–16 kHz	Telefonqualität
Format	WAV oder MP3	Standard
Bitrate	≥ 64 kbps	Codec-Qualität
Kanäle	Mono	Standard für Anrufe

Für Meetings (Zoom, Teams)

Parameter	Wert	Grund
Abtastrate	16–48 kHz	Hohe Qualität
Format	MP4 (Audio extrahieren)	Videoformat
Bitrate	≥ 128 kbps	Gute Qualität
Kanäle	Mono oder Stereo	Abhängig vom Setup

Für Podcasts

Parameter	Wert	Grund
Abtastrate	44,1–48 kHz	Professionelle Qualität
Format	MP3, WAV oder M4A	Übliche Formate
Bitrate	≥ 128 kbps	Gute Qualität
Kanäle	Mono	Standard für Podcasts

Für Interviews

Parameter	Wert	Grund
Abtastrate	16–48 kHz	Hohe Qualität
Format	WAV oder FLAC	Maximale Genauigkeit
Bitrate	Verlustfrei oder ≥ 192 kbps	Professionell
Kanäle	Mono	Standard

---

Zusammenfassung: Whisper Audioanforderungen

Mindestanforderungen

• ✅ Format: Jedes von FFmpeg unterstützte Format
• ✅ Abtastrate: Beliebig (8 kHz Minimum empfohlen)
• ✅ Bittiefe: 8-Bit oder höher
• ✅ Kanäle: Mono oder Stereo (Mono bevorzugt)
• ✅ Dateigröße: Kein hartes Limit (bei > 100 MB chunken)
• ✅ Dauer: Kein hartes Limit (bei > 1 Stunde chunken)

Optimale Anforderungen

• ✅ Format: WAV, FLAC oder MP3 (≥128 kbps)
• ✅ Abtastrate: 16 kHz (optimal, kein Resampling)
• ✅ Bittiefe: 16-Bit-PCM
• ✅ Kanäle: Mono
• ✅ Qualität: Klare Sprache, wenig Rauschen
• ✅ Vorverarbeitung: Normalisierter Pegel, kein Clipping

---

Schnellreferenz: Checkliste zur Audiovorbereitung

• Format: WAV, MP3, FLAC, M4A oder anderes unterstütztes Format
• Abtastrate: 16 kHz (optimal) oder eine unterstützte Rate
• Bittiefe: 16-Bit (empfohlen)
• Kanäle: Mono (bevorzugt) oder Stereo
• Dateigröße: < 100 MB (oder Chunking planen)
• Dauer: < 1 Stunde (oder Chunking planen)
• Qualität: Klare Sprache, wenig Hintergrundgeräusch
• Pegel: Normalisiert, kein Clipping
• Codec: Verlustfrei (WAV/FLAC) oder hochwertig lossy (MP3 ≥128 kbps)

---

Audio testen

Schnelltest

import whisper

# Load model
model = whisper.load_model("base")

# Test transcription
result = model.transcribe("your_audio.wav")

# Check if successful
if result["text"]:
    print("✅ Audio format is compatible")
    print(f"Detected language: {result['language']}")
else:
    print("⚠️ Transcription failed - check audio format")

Häufige Fehlermeldungen

Fehler	Ursache	Lösung
"File not found"	Falscher Pfad	Pfad prüfen
"Unsupported format"	Format nicht unterstützt	Nach WAV/MP3 konvertieren
"Out of memory"	Datei zu groß	Audio chunken
"Empty audio"	Beschädigte Datei	Datei neu kodieren

---

Zusammenfassung bewährter Methoden

1. 16 kHz Abtastrate wenn möglich (optimal für Whisper)
2. Mono bevorzugen gegenüber Stereo (Whisper arbeitet intern mit Mono)
3. Verlustfreie Formate (WAV/FLAC) für maximale Genauigkeit
4. Lange Dateien chunken (> 1 Stunde) für bessere Genauigkeit und Stabilität
5. Audio normalisieren auf gleichmäßigen Pegel
6. Hintergrundgeräusch minimieren für beste Ergebnisse
7. Passende Modellgröße (größere Modelle verarbeiten schlechtes Audio besser)
8. Zuerst mit Base-Modell testen bevor größere Modelle genutzt werden

---

Fazit

• Format: WAV, FLAC oder MP3 (≥128 kbps)
• Abtastrate: 16 kHz (optimal)
• Bittiefe: 16-Bit-PCM
• Kanäle: Mono
• Qualität: Klare Sprache bei minimalem Rauschen

---