Requisiti audio di Whisper: guida completa ai formati supportati e alle specifiche

---

Formati audio supportati

Formati audio

Formato	Estensione	Note
WAV	.wav	✅ Preferito, lossless
MP3	.mp3	✅ Molto comune
FLAC	.flac	✅ Lossless, buona compressione
M4A	.m4a	✅ Formato Apple, codec AAC
AAC	.aac	✅ Compressione di alta qualità
OGG	.ogg	✅ Formato open source
OPUS	.opus	✅ Bassa latenza, adatto al web
WMA	.wma	⚠️ Meno comune
AMR	.amr	⚠️ Bassa qualità, registrazioni telefoniche

Formati video (estrazione audio)

Formato	Estensione	Note
MP4	.mp4	✅ Formato video più comune
AVI	.avi	✅ Formato datato, ancora supportato
MKV	.mkv	✅ Contenitore
MOV	.mov	✅ QuickTime
WebM	.webm	✅ Video web
FLV	.flv	⚠️ Flash legacy

---

Requisiti di frequenza di campionamento

Frequenza ottimale: 16 kHz

Frequenze supportate

Frequenza in ingresso	Elaborazione Whisper	Raccomandazione
8 kHz	Ricampionata a 16 kHz	✅ Chiamate, accettabile
16 kHz	Usata direttamente	✅ Ottimale, nessun ricampionamento
22,05 kHz	Ricampionata a 16 kHz	✅ Buona qualità
44,1 kHz	Ricampionata a 16 kHz	✅ Qualità CD, ok
48 kHz	Ricampionata a 16 kHz	✅ Audio professionale, ok
96 kHz	Ricampionata a 16 kHz	⚠️ Inutile, file più grandi

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)

---

Requisiti di profondità di bit

Profondità supportate

Profondità	Stato	Note
8 bit	✅ Supportata	Bassa qualità, sconsigliata
16 bit	✅ Consigliata	Standard, sufficiente
24 bit	✅ Supportata	Professionale, file più grandi
32 bit float	✅ Supportata	Qualità studio, spesso eccessiva

---

Configurazione canali: mono vs stereo

Mono (consigliato)

• File più piccoli
• Elaborazione più veloce
• Nessun mixaggio canali necessario
• Ottimo per un solo parlante

• Registrazioni con un parlante
• Chiamate telefoniche
• Podcast con un host
• La maggior parte delle attività di trascrizione

Stereo (supportato)

• Parlanti separati su canali diversi (raro)
• La registrazione originale è stereo (conversione automatica)

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)

---

Limiti di dimensione file

Limiti pratici

Dimensione	Tempo di elaborazione	Raccomandazione
< 10 MB	Secondi	✅ Ideale
10–100 MB	Minuti	✅ Buono
100–500 MB	10–30 minuti	⚠️ Valuta il chunking
> 500 MB	30+ minuti	⚠️ Chunking obbligatorio

Memoria

• Modello base: ~1–2 GB VRAM
• Modello small: ~2–3 GB VRAM
• Modello medium: ~5–6 GB VRAM
• Modello large: ~10–12 GB VRAM

---

Limiti di durata

Durata consigliata

Durata	Stato	Note
< 30 minuti	✅ Ottimale	Elaborazione diretta
30–60 minuti	✅ Buono	Può servire il chunking
1–2 ore	⚠️ Chunking consigliato	Spesso più accurato a segmenti
> 2 ore	⚠️ Chunking obbligatorio	Necessario per stabilità

Perché segmentare audio lunghi?

1. Limiti di memoria: evita errori di memoria insufficiente
2. Migliore accuratezza: segmenti più piccoli mantengono meglio il contesto
3. Elaborazione più veloce: possibile parallelismo
4. Recupero errori: se un segmento fallisce, altri possono riuscire

# 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

---

Requisiti di qualità audio

Standard minimi

Fattore	Minimo	Ottimale
Rapporto segnale/rumore	> 10 dB	> 20 dB
Bitrate (MP3)	≥ 64 kbps	≥ 128 kbps
Livello volume	Udibile	Normalizzato a −3 dB
Rumore di fondo	Minimo	Nessuno
Eco/riverbero	Minimi	Nessuno

Checklist qualità

• ✅ Parlato chiaro: i parlanti sono comprensibili
• ✅ Poco rumore: lo sfondo non copre la voce
• ✅ Volume costante: nessun salto improvviso
• ✅ Nessun clipping: nessuna distorsione o saturazione
• ✅ Buon microfono: attrezzatura adeguata

---

Requisiti di codec

Codec consigliati

Codec	Formato	Qualità	Raccomandazione
PCM	WAV	Lossless	✅ Migliore per accuratezza
FLAC	FLAC	Lossless	✅ Eccellente, compresso
AAC	M4A, MP4	Alta	✅ Molto buono
MP3	MP3	Lossy	✅ Buono a ≥128 kbps
OGG Vorbis	OGG	Lossy	✅ Buona qualità
OPUS	OPUS	Lossy	✅ Buono, bassa latenza

Best practice sui codec

• Usa PCM (WAV) o FLAC (lossless)

• Usa AAC o MP3 a ≥128 kbps (ottimi risultati)

• MP3 a bitrate molto basso (< 64 kbps)
• Formati fortemente compressi
• Codec telefonici (AMR, G.711) salvo necessità

---

Raccomandazioni di preprocessing

Prima della trascrizione

1. Normalizzare il volume

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. Rimuovere il silenzio

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

3. Riduzione del rumore (opzionale)

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

4. Ricampionare a 16 kHz (opzionale)

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)

---

Problemi audio comuni e soluzioni

Problema 1: frequenza di campionamento molto bassa (8 kHz)

• Usa il modello medium o large di Whisper (migliore a basse frequenze)
• Sovracampiona a 16 kHz (non ripristina la qualità ma aiuta l’elaborazione)

Problema 2: stereo con parlanti diversi

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

Problema 3: MP3 a bitrate variabile

• Converti in bitrate costante (CBR) o WAV
• Whisper gestisce bene il VBR; il CBR è più prevedibile

Problema 4: file audio corrotti

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

Problema 5: file audio molto lunghi

• Dividi in segmenti da 30–60 secondi
• Elabora in sequenza o in parallelo
• Unisci i risultati con timestamp

---

Raccomandazioni per scenario

Per chiamate telefoniche

Parametro	Valore	Motivo
Frequenza	8–16 kHz	Qualità telefonica
Formato	WAV o MP3	Standard
Bitrate	≥ 64 kbps	Qualità codec
Canali	Mono	Standard

Per riunioni (Zoom, Teams)

Parametro	Valore	Motivo
Frequenza	16–48 kHz	Alta qualità
Formato	MP4 (estrai audio)	Video
Bitrate	≥ 128 kbps	Buona qualità
Canali	Mono o stereo	Dipende dal setup

Per podcast

Parametro	Valore	Motivo
Frequenza	44,1–48 kHz	Qualità professionale
Formato	MP3, WAV o M4A	Comuni
Bitrate	≥ 128 kbps	Buona qualità
Canali	Mono	Standard

Per interviste

Parametro	Valore	Motivo
Frequenza	16–48 kHz	Alta qualità
Formato	WAV o FLAC	Massima accuratezza
Bitrate	Lossless o ≥ 192 kbps	Professionale
Canali	Mono	Standard

---

Riepilogo: requisiti audio Whisper

Requisiti minimi

• ✅ Formato: qualsiasi formato supportato da FFmpeg
• ✅ Frequenza: qualsiasi (consigliato minimo 8 kHz)
• ✅ Profondità bit: 8 bit o superiore
• ✅ Canali: mono o stereo (preferito mono)
• ✅ Dimensione file: nessun limite rigido (chunk se > 100 MB)
• ✅ Durata: nessun limite rigido (chunk se > 1 ora)

Requisiti ottimali

• ✅ Formato: WAV, FLAC o MP3 (≥128 kbps)
• ✅ Frequenza: 16 kHz (ottimale, nessun ricampionamento)
• ✅ Profondità: PCM 16 bit
• ✅ Canali: mono
• ✅ Qualità: parlato chiaro, poco rumore
• ✅ Preprocessing: volume normalizzato, nessun clipping

---

Riferimento rapido: checklist preparazione audio

• Formato: WAV, MP3, FLAC, M4A o altro supportato
• Frequenza: 16 kHz (ottimale) o altra supportata
• Profondità bit: 16 bit (consigliata)
• Canali: mono (preferito) o stereo
• Dimensione: < 100 MB (o pianifica chunk)
• Durata: < 1 ora (o pianifica chunk)
• Qualità: parlato chiaro, poco rumore di fondo
• Volume: normalizzato, nessun clipping
• Codec: lossless (WAV/FLAC) o lossy di alta qualità (MP3 ≥128 kbps)

---

Testare l’audio

Test rapido

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

Messaggi di errore comuni

Errore	Causa	Soluzione
"File not found"	Percorso errato	Verifica il percorso
"Unsupported format"	Formato non supportato	Converti in WAV/MP3
"Out of memory"	File troppo grande	Segmenta l’audio
"Empty audio"	File corrotto	Ricodifica

---

Riepilogo best practice

1. Usa 16 kHz quando possibile (ottimale per Whisper)
2. Preferisci il mono allo stereo (Whisper elabora in mono)
3. Usa formati lossless (WAV/FLAC) per massima accuratezza
4. Segmenta file lunghi (> 1 ora) per accuratezza e stabilità
5. Normalizza l’audio a livelli coerenti
6. Riduci il rumore di fondo per risultati migliori
7. Scegli la dimensione del modello (i modelli grandi gestiscono meglio audio difficile)
8. Prova prima con base prima di modelli più grandi

---

Conclusione

• Formato: WAV, FLAC o MP3 (≥128 kbps)
• Frequenza: 16 kHz (ottimale)
• Profondità: PCM 16 bit
• Canali: mono
• Qualità: parlato chiaro con poco rumore

---