Option 1 : Filtres de normalisation intégrés

Current ffmpeg possède deux filtres qui peuvent être directement utilisés pour la normalisation - bien qu'ils soient déjà assez avancés, ils n'appliquent donc pas simplement le gain pour atteindre un niveau de crête. Les voici :

• loudnorm : normalisation de l'intensité sonore selon la norme R128 de l'UER. Vous pouvez définir une cible de volume sonore intégrée, une cible de plage de volume sonore ou un pic réel maximum. Cette méthode est recommandée pour la publication d'audio et de vidéo et est utilisée par les diffuseurs du monde entier.
• dynaudnorm : normalisation “intelligente” du volume sonore sans écrêtage, qui applique la normalisation de façon dynamique sur les parties fenêtrées du fichier. Cela peut modifier les caractéristiques du son, et doit donc être appliqué avec prudence.

De plus, le filtre volume peut être utilisé pour effectuer de simples réglages de volume. Voir l'entrée du wiki Manipulation du volume audio pour en savoir plus.

Le filtre loudnorm peut être utilisé avec une seule passe, mais il est recommandé d'effectuer deux passes, ce qui permet une normalisation linéaire plus précise. C'est un peu difficile à automatiser. De plus, si vous souhaitez une normalisation “simple” basée sur le RMS ou la crête à 0 dBFS (ou toute autre cible), lisez ce qui suit.

Option 2 : Utiliser l'outil ffmpeg-normalize

J'ai créé un programme Python pour normaliser les fichiers média , disponible sur PyPi également . Il suffit de :

• télécharger ffmpeg (choisir un static build, version 3. 1 ou supérieure)
• mettre l'exécutable ffmpeg dans votre $PATH en l'ajoutant, par exemple, dans /usr/local/bin, ou ajouter son répertoire à $PATH
• exécuter pip install ffmpeg-normalize
• utiliser ffmpeg-normalize

Par exemple :

ffmpeg-normalize input.mp4 -o output.mp4 -c:a aac -b:a 192k

Ou, pour simplement normaliser par lots un certain nombre de fichiers audio et les écrire en WAV non compressé dans un dossier de sortie :

ffmpeg-normalize *.m4a -of /path/to/outputFolder -ext wav

L'outil prend en charge la norme R128 de l'UER (par défaut), RMS et peak. Consultez la page ffmpeg-normalize -h pour plus d'options et la page README pour quelques exemples.

Il prend également en charge le réencodage avec d'autres encodeurs (par exemple, AAC ou MP3), ou la fusion automatique de l'audio dans la vidéo.

Option 3 : Normalisation manuelle de l'audio avec ffmpeg

Dans ffmpeg, vous pouvez utiliser le filtre volume pour modifier le volume d'une piste. Assurez-vous que vous téléchargez une version récente du programme.

Ce guide est destiné à la normalisation des crêtes, c'est-à-dire qu'il fera en sorte que la partie la plus forte du fichier se situe à 0 dB au lieu de quelque chose de plus faible. Il existe également une normalisation basée sur le RMS qui tente de rendre le volume sonore moyen identique dans plusieurs fichiers. Pour ce faire, n'essayez pas de pousser le volume maximum à 0 dB, mais le volume moyen au niveau dB de votre choix (par exemple -26 dB).

Trouvez le gain à appliquer

Vous devez d'abord analyser le flux audio pour le volume maximum afin de voir si la normalisation serait même payante :

ffmpeg -i video.avi -af "volumedetect" -vn -sn -dn -f null /dev/null

Remplacer /dev/null par NUL sur Windows.
Les arguments -vn , -sn , et -dn indiquent à ffmpeg d'ignorer les flux non audio pendant cette analyse. Cela accélère considérablement l'analyse.

Cela donnera quelque chose comme ce qui suit :

[Parsed_volumedetect_0 @ 0x7f8ba1c121a0] mean_volume: -16.0 dB
[Parsed_volumedetect_0 @ 0x7f8ba1c121a0] max_volume: -5.0 dB
[Parsed_volumedetect_0 @ 0x7f8ba1c121a0] histogram_0db: 87861

Comme vous pouvez le voir, notre volume maximum est de -5,0 dB, ce qui nous permet d'appliquer un gain de 5 dB. Si vous obtenez une valeur de 0 dB, alors vous n'avez pas besoin de normaliser le son.

Appliquez le filtre de volume :

Maintenant, nous appliquons le filtre [ volume (http://ffmpeg.org/ffmpeg-filters.html#volume)] à un fichier audio. Notez que l'application du filtre signifie que nous devrons réencoder le flux audio. Le codec que vous voulez pour l'audio dépend bien sûr du format d'origine. Voici quelques exemples :

• Fichier audio simple: Encodez simplement le fichier avec le codec dont vous avez besoin :

• Format AVI: Habituellement, il y a de l'audio MP3 avec de la vidéo qui vient dans un conteneur AVI :

• Format MP4: Avec un conteneur MP4, vous trouverez généralement de l'audio AAC. Nous pouvons utiliser l'encodeur AAC intégré à ffmpeg.

Dans les exemples ci-dessus, le flux vidéo sera copié en utilisant le format -c:v copy. S'il y a des sous-titres dans votre fichier d'entrée, ou plusieurs flux vidéo, utilisez l'option -map 0 avant le nom du fichier de sortie.

Je ne peux pas commenter le meilleur message, donc c'est mon affreux coup basé sur ça pour faire ça

ffmpeg -i sound.mp3 -af volumedetect -f null -y nul &> original.txt
grep "max_volume" original.txt > original1.tmp
sed -i 's|: -|=|' original1.tmp
if [$? = 0]
 then
 sed -i 's| |\r\n|' original.tmp
 sed -i 's| |\r\n|' original.tmp
 sed -i 's| |\r\n|' original.tmp
 sed -i 's| |\r\n|' original.tmp
 grep "max_volume" original1.tmp > original2.tmp
 sed -i 's|max_volume=||' original2.tmp
 yourscriptvar=$(cat "./original2.tmp")dB
 rm result.mp3
 ffmpeg -i sound.mp3 -af "volume=$yourscriptvar" result.mp3
 ffmpeg -i result.mp3 -af volumedetect -f null -y nul &> result.txt
fi

Voici un script pour normaliser les niveaux sonores des fichiers .m4a. Attention si les niveaux sonores sont trop faibles au départ. Le son final peut être meilleur si vous utilisez dans ce cas quelque chose comme Audacity.

#!/bin/bash

# Purpose: Use ffmpeg to normalize .m4a audio files to bring them up to max volume, if they at first have negative db volume. Doesn't process them if not. Keeps bitrate same as source files.
# Parameters: $1 should be the name of the directory containing input .m4a files.
# $2 should be the output directory.

INPUTDIR=$1
OUTPUTDIR=$2

<<"COMMENT"

# For ffmpeg arguments http://superuser.com/questions/323119/how-can-i-normalize-audio-using-ffmpeg
# and
# https://kdecherf.com/blog/2012/01/14/ffmpeg-converting-m4a-files-to-mp3-with-the-same-bitrate/
ffmpeg -i test.m4a -af "volumedetect" -f null /dev/null

ffmpeg -i test.m4a -af "volumedetect" -f null /dev/null 2>&1 | grep max_volume
# output: max_volume: -10.3 dB

ffmpeg -i test.m4a -af "volumedetect" -f null /dev/null 2>&1 | grep 'max_volume\|Duration'
# Output:
# Duration: 00:00:02.14, start: 0.000000, bitrate: 176 kb/s
# [Parsed_volumedetect_0 @ 0x7f8531e011a0] max_volume: -10.3 dB

ffmpeg -i test.m4a -af "volumedetect" -f null /dev/null 2>&1 | grep max_volume | awk -F': ' '{print $2}' | cut -d' ' -f1
# Output: -10.3

ffmpeg -i test.m4a 2>&1 | grep Audio
# output: Stream #0:0(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 170 kb/s (default)

ffmpeg -i test.m4a 2>&1 | grep Audio | awk -F', ' '{print $5}' | cut -d' ' -f1
# output: 170

# This works, but I get a much smaller output file. The sound levels do appear normalized.
ffmpeg -i test.m4a -af "volume=10.3dB" -c:v copy -c:a aac -strict experimental output.m4a

# Operates quietly.
ffmpeg -i test.m4a -af "volume=10.3dB" -c:v copy -c:a aac -strict experimental -b:a 192k output.m4a -loglevel quiet

COMMENT

# $1 (first param) should be the name of a .m4a input file, with .m4a extension
# $2 should be name of output file, with extension
function normalizeAudioFile {
    INPUTFILE=$1
    OUTPUTFILE=$2

    DBLEVEL=`ffmpeg -i ${INPUTFILE} -af "volumedetect" -f null /dev/null 2>&1 | grep max_volume | awk -F': ' '{print $2}' | cut -d' ' -f1`

    # We're only going to increase db level if max volume has negative db level.
    # Bash doesn't do floating comparison directly
    COMPRESULT=`echo ${DBLEVEL}'<'0 | bc -l`
    if [${COMPRESULT} -eq 1]; then
        DBLEVEL=`echo "-(${DBLEVEL})" | bc -l`
        BITRATE=`ffmpeg -i ${INPUTFILE} 2>&1 | grep Audio | awk -F', ' '{print $5}' | cut -d' ' -f1`

        # echo $DBLEVEL
        # echo $BITRATE

        ffmpeg -i ${INPUTFILE} -af "volume=${DBLEVEL}dB" -c:v copy -c:a aac -strict experimental -b:a ${BITRATE}k ${OUTPUTFILE} -loglevel quiet

    else
        echo "Already at max db level:" $DBLEVEL "just copying exact file"
        cp ${INPUTFILE} ${OUTPUTFILE}
    fi
}

for inputFilePath in ${INPUTDIR}/*; do
    inputFile=$(basename $inputFilePath)
    echo "Processing input file: " $inputFile
    outputFilePath=${OUTPUTDIR}/$inputFile
    normalizeAudioFile ${inputFilePath} ${outputFilePath}
done

ffmpeg -i image.jpg -i “input.mp3” -acodec copy tmp.avi

mencoder -ovc copy -oac copy tmp.avi -of rawaudio -af volnorm=1 -oac mp3lame -lameopts cbr:preset=192 -srate 48000 -o “output.mp3”

rm -f tmp.avi