Ich suche nach einer Möglichkeit, den Ton in VIELEN MP3-Dateien, die ich habe, zu normalisieren. Einige haben einen niedrigen Klang, während andere lauter sind, so dass ich die Lautstärke je nach Song lauter oder leiser stellen muss. Welche Möglichkeiten gibt es, dies für alle Dateien zu tun? Ich würde es besonders gerne über das Terminal machen, aber es werden auch GUI-Wege akzeptiert.

Kühnheit

Mit Audacity können wir Dateien einfach stapelweise verarbeiten , um Konvertierungen oder Effekte auf viele Dateien in einer Liste anzuwenden. Dazu müssen wir zuerst eine "Kette" definieren, die die Effekte enthält, die wir anwenden möchten.

Dies geschieht mit "Datei -> Ketten bearbeiten ..." . Drücken Sie im sich öffnenden Fenster die Schaltfläche Hinzufügen unten links, um eine neue Kette einzufügen (geben Sie ihr einen sinnvollen Namen):

Wählen Sie dann den Effekt und seine Parameter aus, die in die Kette eingefügt werden sollen (hier gezeigt für Standardwerte und den Effekt "Normalisieren").

Wichtig: Wir müssen immer auch den Effekt "MP3 exportieren " (oder ein anderes Exportformat) hinzufügen, um die resultierende Konvertierung auf der Festplatte zu speichern.

Wenn Sie fertig sind, verlassen Sie dieses Fenster mit OK , um "Datei -> Kette anwenden ..." zu öffnen . Wählen Sie die gerade erstellte Kette aus und laden Sie alle benötigten Dateien mit "Auf Dateien anwenden ..." . In der sich öffnenden Dateiauswahl können mehrere Dateien ausgewählt werden.

Verarbeitete Dateien werden in einem neuen Unterverzeichnis "bereinigt" im Pfad des Originals gespeichert .

SoX

Ab Version> 14.3 können wir den Sox-Filter --normzum Normalisieren von Audio in der Befehlszeile oder für die Stapelverarbeitung verwenden:

sox --norm infile outfile

MP3-Unterstützung wird Sox mit libsox-fmt-all hinzugefügt:

sudo apt install sox libsox-fmt-all

Schaut mal bei mp3gain vorbei, das ist für mich sogar besser als normalize-audio

mp3gain -r *.mp3

Eine andere nützliche Version könnte -c sein, das verhindert, dass Sie gefragt werden, ob Sie die Änderungen für viele Dateien vornehmen möchten:

mp3gain -c -r *.mp3

Wie in der Manpage gesagt:

mp3gain normalisiert nicht nur Spitzenwerte, wie es viele Normalisierer tun. Stattdessen werden statistische Analysen durchgeführt, um festzustellen, wie laut die Datei für das menschliche Ohr tatsächlich ist. Auch die Änderungen, die mp3gain vornimmt, sind völlig verlustfrei. Bei der Änderung geht keine Qualität verloren, da das Programm die MP3-Datei direkt anpasst, ohne sie zu dekodieren und neu zu kodieren.

Hinweis : Das Paket wurde entfernt absichtlich auf Ubuntu 15.04.

Debian schlägt das python-rgainPaket als Ersatz vor (Der Vorteil ist, dass 'Replaygain' verschiedene Dateiformate unterstützt, nämlich Ogg Vorbis, Flac, WavPack und MP3. Außerdem können Sie vorhandene Replay Gain-Informationen in jedem dieser Dateitypen anzeigen). Führen Sie nach der Installation das Programm aus replaygain.

Führen Sie den Befehl aus, um python-rgain vom Terminal aus zu installieren

sudo apt-get install python-rgain

Alternativ können Sie die .debDatei für 14.04 (spätestens) hier herunterladen . Wie gewohnt installieren. Danach müssen Sie ausgeführt werden sudo apt-get -f install, um einige Probleme mit Abhängigkeiten zu beheben.

Ich würde dieses Projekt Normalize verwenden , es ist ein Befehlszeilen-Tool zum Normalisieren von Audiodateien. Sieht genau so aus, wie Sie es brauchen. Kann Batch-Verarbeitung durchführen und erfordert kein Resampling in Zwischenformate.

Es ist in dem Paket repos als Normalisieren-Audio, sudo apt-get install normalize-audio. Dies ist ein Build, der von Debian im Upstream gepflegt wird, so dass es in LTS oder neueren Versionen sein sollte und mit mp3-Kompatibilität (getestet) erstellt wurde. Es gibt eine gute Manpage man normalize-audio, um die Optionen zu erkunden, aber die Standardeinstellungen der Befehle scheinen gut zu funktionieren. Für die Stapelverarbeitung (normalisieren Sie das Volume über mehrere Dateien) normalize-audio -b *.mp3oder geben Sie einzelne Dateinamen an, anstatt Platzhalter zu verwenden.

noch einmal spielen

Schneller und einfacher replaygain:

Dieses Paket enthält ein Python-Paket, mit dem die Wiedergabegewinnwerte von Audiodateien berechnet und die Lautstärke dieser Dateien entsprechend den Werten normalisiert werden kann. Zwei grundlegende Skripte, die diese Funktionen nutzen, werden ebenfalls mitgeliefert.

Replay Gain ist ein vorgeschlagener Standard, der genau das Problem der Lautstärkeänderung in Audiodateien lösen soll.

Installation: sudo apt install python-rgain.

replaygain --force *.mp3

• -f, --force Berechnen Sie die Wiederholungsverstärkung neu, auch wenn die Datei bereits Verstärkungsinformationen enthält.

Da nur der Wiedergabewert berechnet / geändert werden kann, geht das auch schneller: Bei einem durchschnittlichen PC (Intel i7-6500U, 8GB RAM) lag die Rate bei ~ 20 Dateien / Minute.

Referenz

• ReplayGain-Artikel bei Wikipedia
• python-rgain auf dem Launchpad

Dafür werfe ich meine 2 Cent rein. Ich habe genau dasselbe gesucht (nur für ogg-Dateien) und einen Thread im Crunchbang-Forum gestartet. Sie können es hier ansehen: Normalize-Audio kann den MP3-Decoder nicht finden

Grundsätzlich war meine Lösung das Skript in Post # 8. Es funktioniert für MP3-, FLAC- und OGG-Eingabedateien, möglicherweise für andere, aber definitiv nicht für WAV.

Erstellen Sie einfach eine Datei (benennen Sie sie wie Sie wollen, ich habe meine db_adjust_mp3 genannt), chmod + x und stecken Sie sie in Ihren Ordner ~ / bin. Es füllt auch alle fehlenden Codec-Daten aus. Beispiel:

Originaldatei: 16._This_Protector.mp3: Audio file with ID3 version 2.3.0, contains:

gegen

Normalisierte Datei: 16._This_Protector.mp3: Audio file with ID3 version 2.3.0, contains: MPEG ADTS, layer III, v1, 192 kbps, 44.1 kHz, JntStereo

Ich habe das Skript modifiziert, um normalize-mp3 hier zu verwenden, so dass Sie es verwenden können, wenn Sie möchten:

#!/bin/bash

find "$1" -iname "*.""$2" > $HOME/file_list

cat $HOME/file_list | while read line; do
#  echo "$line"
  orig_gain="$(normalize-mp3 -n "$line" | cut -d 'd' -f1)"
  larger=$(echo "$orig_gain"'>'-12 | bc)
  if [[ larger ]]
    then
      gain_difference=$(echo "$orig_gain"*-1-12 | bc)
    else
      gain_difference=$(echo "$orig_gain"-12 | bc)
  fi
  echo "Gain Difference will be: $gain_difference""db"
  normalize-ogg --mp3 --bitrate "$3" -g "$gain_difference""db" -v "$line"
done

Dieses Skript berechnet die Differenz zwischen dem aktuellen DB-Pegel und -12 dB und nimmt dann eine Verstärkungsanpassung vor, um die Verstärkung auf genau -12 dB zu setzen. Es ist auch rekursiv, was es großartig macht, ganze Musiksammlungen oder Dateien in vielen Unterordnern zu erstellen. Wenn Sie einen anderen DB-Level einstellen möchten, ändern Sie einfach die beiden Instanzen der Zahl "12" auf den gewünschten DB-Level. Wie ich in meinem Crunchbang-Thread gepostet habe, ist die Verwendung wie folgt:

normalize-mp3 <directory> <file extenstion(with no leading dot)> <bitrate>

Als ich meine Musikbibliothek jedoch im MP3-Format hielt, verwendete ich auch mp3gain, genau wie Philippe es vorschlug. Die tote Einfachheit ist großartig und hat mir sehr gut gefallen. Das Problem bei der Normalisierung von Audio ist jedoch, dass die Dateien neu codiert werden, so dass es zu einer gewissen Klangverschlechterung kommt. Aber wenn Sie kein Audiophiler sind und Ihre MP3s mit einer hohen Bitrate codiert sind, sollten Sie keinen großen Unterschied bemerken.

Was mir bei mp3gain jedoch aufgefallen ist, ist, dass ich, egal welche Optionen ich ausprobiert habe, nicht alles in meiner Sammlung auf genau den gleichen DB-Pegel einstellen kann. Das ist es, was ich möchte, damit ich die Lautstärke nie von einem Track auf den anderen einstellen muss der nächste. Dieses Skript macht genau das. Tut mir leid, dass ich so langatmig bin. Hoffe das hilft.

Neils Antwort hat mir am besten gefallen, da sie keine Korrelation zwischen Audiodateien herstellt: Wählen Sie einfach eine Verstärkungsstufe und passen Sie alles daran an.

Ich hatte jedoch einige Probleme beim Parsen der Ausgabe normalize-oggeiniger Dateien, die ich habe. Es gibt auch ein unangenehmes Problem bc: Es wird nicht wirklich gerundet, sondern nur abgeschnitten.

Also habe ich irgendwann das Shell-Scripting aufgegeben und bin zu Python übergegangen.

Hinweis 1: Der exiftool-Teil ist möglicherweise zu viel des Guten, aber ich wollte 100% sicher sein, dass die ursprüngliche Bitrate erhalten bleibt.

Hinweis 2: Dadurch werden die Originale überschrieben . Wenn Sie sie beibehalten möchten, verwenden Sie --backup im letzten Aufruf, um ogg zu normalisieren. Ich fand es jedoch praktischer, eine Kopie in einem separaten, sichereren Verzeichnis zu speichern.

Hinweis 3: Diese Lösung behandelt ogg-Dateien, aber es ist trivial, sie an mp3 anzupassen. Ersetzen Sie einfach das Vorkommen von "ogg" durch "mp3".

Hier ist meine Meinung zum Problem. Die neueste Version finden Sie hier: regain.py

#!/usr/bin/python3
"""
Parallel normalize gains
"""
'
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
'

# Absolute value, in dB for the desired gain of each file
TARGET_GAIN = -12

# 
MAX_THREADS = 2

from subprocess import Popen, PIPE
from multiprocessing.dummy import Pool as ThreadPool
from os import listdir
import logging

def initlogger(logfile="log.log", mainlevel=logging.DEBUG,
               filelevel=logging.DEBUG, consolelevel=logging.DEBUG):
    '''initlogger'''
    # create logger 
    logger = logging.getLogger()
    logger.setLevel(mainlevel)
    # create file handler which logs even debug messages
    fh = logging.FileHandler(logfile)
    fh.setLevel(filelevel)
    # create console handler also logging at DEBUG level
    ch = logging.StreamHandler()
    ch.setLevel(consolelevel)
    # create formatter and add it to the handlers
    formatter = logging.Formatter("%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s]  %(message)s")
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)
    # add the handlers to the logger
    logger.addHandler(fh)
    logger.addHandler(ch)

def logcommand(command=[]):
    '''logcommand'''
    if not isinstance(command, list):
        return "", "", -1
    logging.info("Command:\n" + " ".join(command) + "\n")
    proc = Popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    output, err = proc.communicate()
    output = output.decode("utf-8")
    err = err.decode("utf-8")
    logging.info("Output:\n" + output + "\n")
    logging.info("Error:\n" + err + "\n")
    logging.info("Return Code:\n" + str(proc.returncode) + "\n")
    return output, err, proc.returncode

def regain(target):
    '''regain'''
    logging.info("============================ Start File  ============================")
    logging.warning(target["name"])
    logging.info("Extracting gain info.\n")
    commandgetlevels = ['normalize-ogg', '-n', target["name"]]
    output, err, retcode = logcommand(commandgetlevels)

    level  = output.split()[0]
    logging.debug("Level: " + level)
    if "dBFS" in level:
        level = level.split("dBFS")[0]
    level = level.replace(',', '.')
    level = int(round(float(level)))
    delta = target["gain"] - level
    logging.info("Required adjustment: " + str(delta) + "\n")
    if delta is 0:
        logging.warning(target["name"] + " is already at the correct level")
        return 0

    logging.info("Extracting average bitrate.\n")
    commandgetinfo = ['exiftool', target["name"]]
    output, err, retcode = logcommand(commandgetinfo)
    bitrate = '0'
    for line in output.split('\n'):
        if 'Nominal Bitrate' in line:
            bitrate = line.split(':')[1].split()[0]
            break
    logging.info("Average bitrate is: " + str(bitrate) + "\n")
    if bitrate is '0':
        logging.error("No valid bitrate found, aborting conversion.\n")
        exit(-1)

    logging.info("Re-normalizing.\n")
    commandrenormalize = ['normalize-ogg', '--ogg', '--bitrate', bitrate,
                          '-g', str(delta) + 'db', target["name"]]
    output, err, retcode = logcommand(commandrenormalize)
    if retcode is not 0:
        log.error("Output:\n" + output)
        log.error("err:\n" + err)
        exit(retcode)

    return retcode

# function to be mapped over
def parallelregain(gain=TARGET_GAIN, threads=MAX_THREADS):
    '''parallelregain'''
    logging.info("Creating thread pool with " + str(threads) + " elements.\n")
    pool = ThreadPool(threads)
    targets = []
    files_list = listdir(".")
    files_list.sort()
    counter = 0
    for filename in files_list:
        if filename.endswith("ogg"):
            target = {
                "name":filename,
                "gain":gain,
            }
            targets.append(target)
            counter = counter + 1
    pool.map(regain, targets)
    pool.close()
    pool.join()

if __name__ == "__main__":
    initlogger(logfile="normalize.log", consolelevel=logging.WARNING)
    parallelregain()