Szukam sposobu na znormalizowanie dźwięku w WIELU plikach MP3, które mam. Niektóre mają niski dźwięk, podczas gdy inne są głośniejsze, więc muszę zwiększać lub zmniejszać głośność w zależności od piosenki. Jakie są sposoby, aby to zrobić dla wszystkich plików. Szczególnie chciałbym to zrobić za pośrednictwem terminala, ale sposoby GUI są również akceptowane.

Śmiałość

Dzięki Audacity możemy z łatwością przetwarzać pliki wsadowo, aby zastosować konwersje lub efekty do wielu plików na liście. Aby to zrobić, musimy najpierw zdefiniować „Łańcuch” zawierający efekty, które chcemy zastosować.

Odbywa się to za pomocą „Plik -> Edytuj łańcuchy ...” . W otwartym oknie naciśnij przycisk Dodaj w lewym dolnym rogu, aby wstawić nowy łańcuch (nadaj mu sensowną nazwę):

Następnie wybierz efekt i jego parametry do wstawienia do łańcucha (tutaj pokazano wartości domyślne i efekt Normalizuj).

Ważne: zawsze musimy również dodać efekt „Eksportuj MP3” (lub dowolny inny format eksportu), aby zapisać wynikową konwersję na dysk.

Po zakończeniu pozostaw to okno z OK, aby otworzyć „Plik -> Zastosuj łańcuch ...” . Wybierz właśnie utworzony łańcuch i załaduj wszystkie potrzebne pliki za pomocą „Zastosuj do plików ...” . Można wybrać kilka plików z otwieranego selektora plików.

Przetworzone pliki zostaną zapisane w nowym podkatalogu „oczyszczone” w ścieżce oryginału.

SoX

Od wersji> 14.3 możemy użyć filtra sox --normdo normalizacji dźwięku w linii poleceń lub przetwarzania wsadowego:

sox --norm infile outfile

Obsługa plików MP3 została dodana do Sox za pomocą libsox-fmt-all:

sudo apt install sox libsox-fmt-all

Spójrz na @ mp3gain, który jest dla mnie nawet lepszy niż normalizacja-audio

mp3gain -r *.mp3

inną przydatną wersją może być -c, która nie pozwala zapytać, czy chcesz wprowadzić zmiany dla wielu plików:

mp3gain -c -r *.mp3

jak powiedziano na stronie podręcznika:

mp3gain nie tylko dokonuje szczytowej normalizacji, jak robi to wiele normalizatorów. Zamiast tego wykonuje analizę statystyczną, aby ustalić, jak głośno plik rzeczywiście brzmi dla ludzkiego ucha. Ponadto zmiany wprowadzone przez mp3gain są całkowicie bezstratne. Zmiana nie powoduje utraty jakości, ponieważ program dostosowuje plik mp3 bezpośrednio, bez dekodowania i ponownego kodowania.

Uwaga : Pakiet ten został specjalnie usunięty na Ubuntu 15.04.

Debian proponuje python-rgainpakiet jako zamiennik (zaletą jest to, że 'replaygain' obsługuje kilka formatów plików, a mianowicie Ogg Vorbis, Flac, WavPack i MP3. Pozwala także na przeglądanie istniejących informacji o zyskach powtórek w każdym z tych typów plików). Po zainstalowaniu uruchom replaygain.

Aby zainstalować python-rgain z terminala, uruchom polecenie

sudo apt-get install python-rgain

Możesz też pobrać .debplik 14.04 (najnowszy) stąd . Zainstaluj jak zwykle. Następnie musisz uruchomić, sudo apt-get -f installaby rozwiązać niektóre problemy z zależnościami.

Chciałbym użyć tego projektu Normalizuj , jest to narzędzie wiersza polecenia do normalizacji plików audio. Wygląda dokładnie tak, jak potrzebujesz. Może wykonywać przetwarzanie wsadowe i nie wymaga ponownego próbkowania do formatów pośrednich.

Jest w repo pakiet jako normalizować-audio sudo apt-get install normalize-audio. Jest to kompilacja utrzymywana przez Debiana, więc powinna znajdować się we wszystkich wersjach LTS lub nowszych i jest kompatybilna z mp3 (testowana). Jest dobra strona podręcznika man normalize-audiodo eksploracji opcji, ale domyślne polecenia wydają się działać dobrze. W przypadku przetwarzania wsadowego (znormalizuj wolumin w wielu plikach) normalize-audio -b *.mp3lub określ poszczególne nazwy plików zamiast używać symboli wieloznacznych.

powtórka

Szybciej i łatwiej replaygain:

Ten pakiet zawiera pakiet Python do obliczania wartości wzmocnienia powtórzeń plików audio i normalizacji głośności tych plików zgodnie z wartościami. Dostarczone są również dwa podstawowe skrypty wykorzystujące te możliwości.

Replay Gain jest proponowanym standardem zaprojektowanym w celu rozwiązania bardzo problemu zmiennego poziomu głośności plików audio.

Instalacja: sudo apt install python-rgain.

replaygain --force *.mp3

• -f, --force Przelicz zysk powtórki, nawet jeśli plik zawiera już informacje o wzmocnieniu.

Ponieważ tylko obliczanie / zmiana wartości powtórki jest również szybsze: przy średnim komputerze (Intel i7-6500U, 8 GB pamięci RAM) szybkość wynosiła ~ 20 plików / minutę.

Odniesienie

• ReplayZyskaj artykuł z Wikipedii
• python-rgain w Launchpad

Z tego powodu wrzucę 2 centy. Szukałem dokładnie tego samego (tylko dla plików ogg) i zacząłem wątek na forum Crunchbang. Możesz to zobaczyć tutaj: Normalize-audio nie może znaleźć dekodera mp3

Zasadniczo moim rozwiązaniem był skrypt w poście # 8. Działa z plikami wejściowymi mp3, flac i ogg, prawdopodobnie innymi, ale na pewno nie wav.

Wystarczy utworzyć plik (nazwij go, jak chcesz, nazwałem mój db_adjust_mp3), chmod + x i włóż go do folderu ~ / bin. Uzupełnia również brakujące dane kodeka. Przykład:

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

vs.

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

Zmodyfikowałem skrypt, aby używał tutaj normalize-mp3, więc możesz go użyć, jeśli chcesz:

#!/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

Ten skrypt oblicza różnicę między bieżącym poziomem db a -12db, a następnie stosuje korektę wzmocnienia, aby ustawić wzmocnienie dokładnie na -12db, co według mnie działa najlepiej dla mnie. Jest również rekurencyjny, co czyni go doskonałym do robienia całych kolekcji muzycznych lub plików w wielu podfolderach. Jeśli chcesz ustawić inny poziom db, po prostu zmień oba wystąpienia liczby „12” na dowolny poziom db, którego chcesz użyć. Jak napisałem w moim wątku Crunchbang, użycie jest następujące:

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

Kiedy jednak utrzymywałem bibliotekę muzyczną w formacie mp3, korzystałem także z mp3gain, tak jak sugerował Philippe. Martwa prostota tego jest świetna i bardzo mi się podobała. Problem z normalizacją dźwięku polega na tym, że dekoduje on ponownie kodowanie plików, więc występuje pewna degradacja dźwięku. Ale jeśli nie jesteś audiofilem, a twoje pliki mp3 są zakodowane z dużą szybkością transmisji, nie powinieneś zauważać dużej różnicy.

W mp3gain zauważyłem jednak to, że bez względu na to, jakie wypróbowałem opcje, nie mogłem uzyskać wszystkiego w mojej kolekcji na dokładnie tym samym poziomie db, czego chcę, aby nigdy nie musiałem dostosowywać głośności z jednej ścieżki do Następny. Ten skrypt robi dokładnie to. Przepraszam za bycie tak długo rozwartym Mam nadzieję że to pomoże.

Najbardziej podobała mi się odpowiedź Neila, ponieważ nie wprowadza korelacji między plikami audio: wystarczy wybrać jeden poziom wzmocnienia i wszystko do niego dostosować.

Miałem jednak pewne problemy z analizowaniem danych wyjściowych normalize-oggz niektórymi plikami, które mam. Jest też jeden paskudny problem z bc: nie robi prawdziwego zaokrąglania, tylko obciąża.

W końcu zrezygnowałem ze skryptowania powłoki i przeniosłem się do Pythona.

Uwaga 1: część exiftool może być nadmierna, ale chciałem być w 100% pewien, że oryginalny bitrate zostanie zachowany.

Uwaga 2: spowoduje to nadpisanie oryginałów, jeśli chcesz je zachować, użyj opcji --backup w ostatnim wywołaniu normalize-ogg. Ale bardziej praktyczne było przechowywanie kopii w osobnym, bezpieczniejszym katalogu.

Uwaga 3: to rozwiązanie dotyczy plików ogg, ale dostosowanie go do formatu mp3 jest banalne, wystarczy zastąpić wystąpienia „ogg” słowem „mp3”.

Oto moje podejście do problemu. Najnowszą wersję można znaleźć tutaj: 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()