Whisper-audiovereisten: volledige gids voor ondersteunde formaten en specificaties

---

Ondersteunde audioformaten

Audioformaten

Formaat	Extensie	Opmerkingen
WAV	.wav	✅ Voorkeur, lossless
MP3	.mp3	✅ Meest gebruikelijk
FLAC	.flac	✅ Lossless, goede compressie
M4A	.m4a	✅ Apple-formaat, AAC-codec
AAC	.aac	✅ Hoge kwaliteit compressie
OGG	.ogg	✅ Open-sourceformaat
OPUS	.opus	✅ Lage latentie, webvriendelijk
WMA	.wma	⚠️ Minder gangbaar
AMR	.amr	⚠️ Lage kwaliteit, telefoonopnames

Videoformaten (audio-extractie)

Formaat	Extensie	Opmerkingen
MP4	.mp4	✅ Meest gebruikelijk videoformaat
AVI	.avi	✅ Ouder formaat, nog ondersteund
MKV	.mkv	✅ Containerformaat
MOV	.mov	✅ QuickTime-formaat
WebM	.webm	✅ Webvideoformaat
FLV	.flv	⚠️ Legacy Flash-formaat

---

Sample rate-vereisten

Optimale sample rate: 16 kHz

Ondersteunde sample rates

Invoer-sample rate	Verwerking in Whisper	Aanbeveling
8 kHz	Geresampled naar 16 kHz	✅ Telefoongesprekken, acceptabel
16 kHz	Direct gebruikt	✅ Optimaal, geen resampling
22,05 kHz	Geresampled naar 16 kHz	✅ Goede kwaliteit
44,1 kHz	Geresampled naar 16 kHz	✅ CD-kwaliteit, prima
48 kHz	Geresampled naar 16 kHz	✅ Professionele audio, prima
96 kHz	Geresampled naar 16 kHz	⚠️ Onnodig, grotere bestanden

Best practice

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

---

Bitdiepte-vereisten

Ondersteunde bitdieptes

Bitdiepte	Status	Opmerkingen
8-bit	✅ Ondersteund	Lage kwaliteit, niet aanbevolen
16-bit	✅ Aanbevolen	Standaard, voldoende
24-bit	✅ Ondersteund	Professioneel, grotere bestanden
32-bit float	✅ Ondersteund	Studiokwaliteit, vaak overkill

---

Kanaalconfiguratie: mono vs. stereo

Mono (aanbevolen)

• Kleinere bestanden
• Snellere verwerking
• Geen kanaalmixing nodig
• Optimaal voor één spreker

• Opnames met één spreker
• Telefoongesprekken
• Podcasts met één host
• De meeste transcriptietaken

Stereo (ondersteund)

• Aparte sprekers op verschillende kanalen (zeldzaam)
• Originele opname is stereo (conversie 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)

---

Bestandsgroottelimieten

Praktische grenzen

Bestandsgrootte	Verwerkingstijd	Aanbeveling
< 10 MB	Seconden	✅ Ideaal
10–100 MB	Minuten	✅ Goed
100–500 MB	10–30 minuten	⚠️ Overweeg chunking
> 500 MB	30+ minuten	⚠️ Chunking verplicht

Geheugen

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

---

Duurlimieten

Aanbevolen duur

Duur	Status	Opmerkingen
< 30 minuten	✅ Optimaal	Direct verwerken
30–60 minuten	✅ Goed	Chunking kan nodig zijn
1–2 uur	⚠️ Chunking aanbevolen	Vaak nauwkeuriger met chunks
> 2 uur	⚠️ Chunking verplicht	Nodig voor stabiliteit

Waarom lange audio segmenteren?

1. Geheugengrenzen: Voorkomt geheugenfouten
2. Betere nauwkeurigheid: Kleinere chunks behouden context beter
3. Snellere verwerking: Parallel mogelijk
4. Foutherstel: Als één chunk faalt, slagen andere wel

# 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

---

Audiokwaliteitsvereisten

Minimumstandaarden

Factor	Minimum	Optimaal
Signaal-ruisverhouding	> 10 dB	> 20 dB
Bitrate (MP3)	≥ 64 kbps	≥ 128 kbps
Volume	Hoorbaar	Genormaliseerd naar −3 dB
Achtergrondruis	Minimaal	Geen
Echo/nagalm	Minimaal	Geen

Kwaliteitschecklist

• ✅ Heldere spraak: Sprekers zijn verstaanbaar
• ✅ Minimale ruis: Achtergrond overstemt spraak niet
• ✅ Constant volume: Geen plotselinge veranderingen
• ✅ Geen clipping: Geen vervorming of verzadiging
• ✅ Goede microfoon: Kwalitatieve opnameapparatuur

---

Codec-vereisten

Aanbevolen codecs

Codec	Formaat	Kwaliteit	Aanbeveling
PCM	WAV	Lossless	✅ Beste voor nauwkeurigheid
FLAC	FLAC	Lossless	✅ Uitstekend, gecomprimeerd
AAC	M4A, MP4	Hoog	✅ Zeer goed
MP3	MP3	Lossy	✅ Goed bij ≥128 kbps
OGG Vorbis	OGG	Lossy	✅ Goede kwaliteit
OPUS	OPUS	Lossy	✅ Goed, lage latentie

Codec-best practices

• Gebruik PCM (WAV) of FLAC (lossless)

• Gebruik AAC of MP3 bij ≥128 kbps (uitstekende resultaten)

• Zeer lage MP3-bitrate (< 64 kbps)
• Sterk gecomprimeerde formaten
• Telefooncodecs (AMR, G.711) tenzij nodig

---

Aanbevelingen voor preprocessing

Vóór transcriptie

1. Volume normaliseren

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. Stilte verwijderen

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

3. Ruisonderdrukking (optioneel)

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

4. Resamplen naar 16 kHz (optioneel)

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)

---

Veelvoorkomende audio-problemen en oplossingen

Probleem 1: Zeer lage sample rate (8 kHz)

• Gebruik Whisper medium- of large-model (beter bij lage sample rates)
• Upsamplen naar 16 kHz (herstelt kwaliteit niet, helpt wel bij verwerking)

Probleem 2: Stereo met verschillende sprekers

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

Probleem 3: Variabele bitrate MP3

• Converteer naar constante bitrate (CBR) of WAV
• Whisper handelt VBR goed af; CBR is voorspelbaarder

Probleem 4: Beschadigde audiobestanden

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

Probleem 5: Zeer lange audiobestanden

• Splits in chunks van 30–60 seconden
• Verwerk sequentieel of parallel
• Voeg resultaten samen met tijdstempels

---

Aanbevelingen per scenario

Voor telefoongesprekken

Parameter	Waarde	Reden
Sample rate	8–16 kHz	Telefoniekwaliteit
Formaat	WAV of MP3	Standaard
Bitrate	≥ 64 kbps	Codec-kwaliteit
Kanalen	Mono	Standaard voor gesprekken

Voor vergaderingen (Zoom, Teams)

Parameter	Waarde	Reden
Sample rate	16–48 kHz	Hoge kwaliteit
Formaat	MP4 (audio extraheren)	Videoformaat
Bitrate	≥ 128 kbps	Goede kwaliteit
Kanalen	Mono of stereo	Afhankelijk van setup

Voor podcasts

Parameter	Waarde	Reden
Sample rate	44,1–48 kHz	Professionele kwaliteit
Formaat	MP3, WAV of M4A	Gangbaar
Bitrate	≥ 128 kbps	Goede kwaliteit
Kanalen	Mono	Standaard

Voor interviews

Parameter	Waarde	Reden
Sample rate	16–48 kHz	Hoge kwaliteit
Formaat	WAV of FLAC	Maximale nauwkeurigheid
Bitrate	Lossless of ≥ 192 kbps	Professioneel
Kanalen	Mono	Standaard

---

Samenvatting: Whisper-audiovereisten

Minimumvereisten

• ✅ Formaat: Elk FFmpeg-ondersteund formaat
• ✅ Sample rate: Willekeurig (minimaal 8 kHz aanbevolen)
• ✅ Bitdiepte: 8-bit of hoger
• ✅ Kanalen: Mono of stereo (mono voorkeur)
• ✅ Bestandsgrootte: Geen harde limiet (chunk bij > 100 MB)
• ✅ Duur: Geen harde limiet (chunk bij > 1 uur)

Optimale vereisten

• ✅ Formaat: WAV, FLAC of MP3 (≥128 kbps)
• ✅ Sample rate: 16 kHz (optimaal, geen resampling)
• ✅ Bitdiepte: 16-bit PCM
• ✅ Kanalen: Mono
• ✅ Kwaliteit: Heldere spraak, minimale ruis
• ✅ Preprocessing: Genormaliseerd volume, geen clipping

---

Snelle referentie: checklist audiobereiding

• Formaat: WAV, MP3, FLAC, M4A of ander ondersteund formaat
• Sample rate: 16 kHz (optimaal) of andere ondersteunde rate
• Bitdiepte: 16-bit (aanbevolen)
• Kanalen: Mono (voorkeur) of stereo
• Bestandsgrootte: < 100 MB (of chunking plannen)
• Duur: < 1 uur (of chunking plannen)
• Kwaliteit: Heldere spraak, minimale achtergrondruis
• Volume: Genormaliseerd, geen clipping
• Codec: Lossless (WAV/FLAC) of hoogwaardige lossy (MP3 ≥128 kbps)

---

Uw audio testen

Snelle test

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")

Veelvoorkomende foutmeldingen

Fout	Oorzaak	Oplossing
"File not found"	Verkeerd pad	Pad controleren
"Unsupported format"	Formaat niet ondersteund	Converteren naar WAV/MP3
"Out of memory"	Bestand te groot	Audio segmenteren
"Empty audio"	Beschadigd bestand	Opnieuw encoderen

---

Samenvatting best practices

1. Gebruik 16 kHz sample rate waar mogelijk (optimaal voor Whisper)
2. Geef de voorkeur aan mono boven stereo (Whisper werkt intern mono)
3. Gebruik lossless formaten (WAV/FLAC) voor maximale nauwkeurigheid
4. Segmenteer lange bestanden (> 1 uur) voor nauwkeurigheid en stabiliteit
5. Normaliseer audio naar consistente niveaus
6. Minimaliseer achtergrondruis voor beste resultaten
7. Kies passende modelgrootte (grotere modellen gaan beter om met slechte audio)
8. Test eerst met het base-model vóór grotere modellen

---

Conclusie

• Formaat: WAV, FLAC of MP3 (≥128 kbps)
• Sample rate: 16 kHz (optimaal)
• Bitdiepte: 16-bit PCM
• Kanalen: Mono
• Kwaliteit: Heldere spraak met minimale ruis

---