Estou procurando uma maneira de normalizar o som em MUITOS arquivos MP3 que tenho. Alguns têm som baixo, enquanto outros são mais altos, então eu tenho que aumentar ou diminuir o volume, dependendo da música. Que maneiras existem para fazer isso em todos os arquivos. Eu gostaria especialmente de fazê-lo através do terminal, mas também são aceitas formas de GUI.

Audácia

Com o Audacity, podemos facilmente processar arquivos em lote para aplicar conversões ou efeitos a muitos arquivos em uma lista. Para fazer isso, primeiro precisamos definir uma "Cadeia" contendo os efeitos que queremos aplicar.

Isso é feito com "Arquivo -> Editar cadeias ..." . Na janela agora aberta, pressione o botão Adicionar no canto inferior esquerdo para inserir uma nova corrente (dê um nome sensato):

Em seguida, escolha o efeito e seus parâmetros para inserir na cadeia (aqui mostrados para os valores padrão e o efeito Normalizar).

Importante: sempre precisamos adicionar também o efeito "Export MP3" (ou qualquer outro formato de exportação) para salvar a conversão resultante em disco.

Quando terminar, saia desta janela com OK para abrir "Arquivo -> Aplicar cadeia ..." . Selecione a cadeia que acabamos de criar e carregue todos os arquivos necessários com "Aplicar aos arquivos ..." . Vários arquivos podem ser selecionados no seletor de arquivos que é aberto.

Os arquivos processados ​​serão salvos em um novo subdiretório "limpo" no caminho do original.

SoX

Na versão> 14.3, podemos usar o filtro sox --normpara normalizar o áudio na linha de comando ou para processamento em lote:

sox --norm infile outfile

O suporte a MP3 é adicionado ao Sox com libsox-fmt-all:

sudo apt install sox libsox-fmt-all

Dê uma olhada no mp3gain que, para mim, é ainda melhor do que o áudio normalizado

mp3gain -r *.mp3

outra versão útil pode ser a -c, que impede perguntar se você deseja fazer as alterações para muitos arquivos:

mp3gain -c -r *.mp3

como dito na página de manual:

O mp3gain não apenas normaliza o pico, como muitos normalizadores. Em vez disso, faz algumas análises estatísticas para determinar a intensidade do som do arquivo para o ouvido humano. Além disso, as alterações que o mp3gain faz são completamente sem perdas. Não há perda de qualidade na alteração porque o programa ajusta o arquivo mp3 diretamente, sem decodificar e recodificar.

Nota : Esse pacote foi removido de propósito no ubuntu 15.04.

O Debian propõe o python-rgainpacote como substituto (a vantagem é que o 'replaygain' suporta vários formatos de arquivo, como Ogg Vorbis, Flac, WavPack e MP3. Além disso, permite visualizar as informações existentes sobre o Replay Gain em qualquer um desses tipos de arquivo). Após a instalação, execute replaygain.

Para instalar python-rgain a partir do terminal, execute o comando

sudo apt-get install python-rgain

Como alternativa, obtenha o .debarquivo para 14.04 (o mais recente) aqui . Instale como de costume. Depois disso, você precisa executar sudo apt-get -f installpara corrigir alguns problemas de dependências.

Eu usaria este projeto Normalize , é uma ferramenta de linha de comando para normalizar arquivos de áudio. Parece ser exatamente o que você precisa. Pode processar em lote e não requer reamostragem para formatos intermediários.

Está nos repositórios de pacotes como normalize-audio sudo apt-get install normalize-audio,. Esta é uma compilação mantida a montante pelo Debian, portanto deve estar em qualquer versão LTS ou mais recente e é construída com compatibilidade com mp3 (testada). Há uma boa página de manual man normalize-audiopara explorar as opções, mas os padrões dos comandos parecem funcionar bem. Para processamento em lote (normalize o volume em vários arquivos) normalize-audio -b *.mp3ou especifique nomes de arquivos individuais em vez de usar curingas.

replaygain

Mais rápido e fácil replaygain:

Este pacote fornece um pacote Python para calcular os valores de Replay Gain dos arquivos de áudio e normalizar o volume desses arquivos de acordo com os valores. Também são fornecidos dois scripts básicos que exploram esses recursos.

O Replay Gain é um padrão proposto, projetado para resolver o próprio problema de volumes variados nos arquivos de áudio.

Instalar: sudo apt install python-rgain.

replaygain --force *.mp3

• -f, --force Recalcular ganho de repetição, mesmo que o arquivo já contenha informações de ganho.

Como apenas calcula / altera o valor do replaygain, também é mais rápido: com um PC médio (Intel i7-6500U, 8 GB de RAM), a taxa era de ~ 20 arquivos / minuto.

Referência

• Artigo ReplayGain na Wikipedia
• python-rgain no Launchpad

Por uma questão de segurança, jogarei meus 2 centavos. Eu estava procurando exatamente a mesma coisa (apenas para arquivos ogg) e iniciei um tópico no Crunchbang Forum. Você pode vê-lo aqui: Normalize-audio não consegue encontrar o decodificador mp3

Basicamente, minha solução foi o script no post # 8. Ele funciona para arquivos de entrada mp3, flac e ogg, possivelmente outros, mas definitivamente não é wav.

Basta criar um arquivo (nomeie o que quiser, chamei de meu db_adjust_mp3), chmod + x, e cole-o na sua pasta ~ / bin. Ele preenche todos os dados de codec ausentes também. Exemplo:

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

vs.

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

Modifiquei o script para usar o normalize-mp3 aqui, para que você possa usá-lo se desejar:

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

Esse script calcula a diferença entre o nível atual de db e -12db e aplica um ajuste de ganho para colocar o ganho exatamente em -12db, que foi o que eu achei melhor para mim. Também é recursivo, o que o torna ótimo para fazer coleções ou arquivos de música inteiros em várias subpastas. Se você deseja definir um nível de banco de dados diferente, basta alterar as duas instâncias do número "12" para o nível de banco de dados que você deseja usar. Conforme postei no meu tópico do Crunchbang, o uso é o seguinte:

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

No entanto, quando eu mantinha minha biblioteca de músicas no formato mp3, também usava o mp3gain, como sugeriu Philippe. A simplicidade absoluta disso é ótima e eu realmente gostei. O problema com o áudio de normalização é que ele decodifica e codifica novamente os arquivos, para que haja alguma degradação do som. Mas, a menos que você seja um audiófilo e seus mp3 sejam codificados com uma taxa de bits alta, você não deve notar muita diferença.

O que notei com o mp3gain foi que, independentemente das opções que eu tentei, não consegui que tudo na minha coleção tivesse exatamente o mesmo nível de db, que é o que eu quero, para que eu nunca precise ajustar o volume de uma faixa para outra. nas próximas. Este script faz exatamente isso. Desculpe por ter ficado muito tempo sem ar. Espero que isto ajude.

Gostei mais da resposta de Neil, porque ela não introduz correlação entre arquivos de áudio: basta escolher um nível de ganho e ajustar tudo a ele.

No entanto, tive alguns problemas ao analisar a saída normalize-oggcom alguns arquivos que tenho. Há também um problema desagradável bc: ele não faz arredondamentos reais, apenas trunca.

Por fim, desisti de scripts de shell e mudei para python.

Nota1: a parte do exiftool pode ser um exagero, mas eu queria ter 100% de certeza de que a taxa de bits original seria preservada.

Nota 2: isso substituirá os originais. Se você quiser preservá-los, use --backup na última chamada para normalizar-ogg. Mas achei mais prático manter uma cópia em um diretório separado e mais seguro.

Nota 3: esta solução lida com arquivos ogg, mas é trivial adaptá-lo ao mp3, basta substituir as ocorrências de "ogg" por "mp3".

Aqui está minha opinião sobre o problema. A versão mais recente pode ser encontrada aqui: 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()