Como normalizar o som em arquivos mp3

39

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.

Luis Alvarado
fonte
Para normalizar enquanto estiver jogando, consulte: askubuntu.com/questions/95716/… . Este, porém, não vai mudar o seu conteúdo de arquivo mp3 - pode ser de vantagem;)
Takkat
Não durante a reprodução, não quero defini-lo todas as vezes ou ter um reprodutor definido como normalizado toda vez que quero ouvir as músicas. Por exemplo, digamos que eu quero copiar as músicas para um iPod shuffle ou para um pen drive para ouvir em um tocador de mp3.
Luis Alvarado
@Takkat BTW bem feito nessa outra questão. Boa informação.
Luis Alvarado
11
Minha esposa acabou de testar o método Audacity, e funcionou perfeitamente! Recomendado. Por favor, quando as pessoas pedem conselhos, é porque NÃO são especialistas. Portanto, não diga a eles para usar ferramentas de linha de comando quando puderem fazer o trabalho com ferramentas gráficas fáceis de entender como o Audacity. Dizer aos novos usuários do Linux para abrirem terminais e executarem ferramentas de linha de comando apenas os afasta do Ubuntu, com a sensação de que o Windows é simples, o Linux é difícil. Não é uma surpresa que o DOS esteja morto, mas o Windows esteja vivo.
É ótimo que sua esposa tenha conseguido descobrir o caminho gráfico, mas você perdeu a parte em que a pessoa que fazia a pergunta especificamente queria alcançá-la através do terminal?
RichardP

Respostas:

22

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

insira a descrição da imagem aqui

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.

insira a descrição da imagem aqui

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
Takkat
fonte
2
Essas ferramentas decodificam e recodificam?
Qed 29/14 /
Você não pode normalizar sem a re-codificar, pelo menos os níveis ...
Takkat
Para normalização ao vivo não destrutiva usando LADSPA e pulseaudio,
Takkat 29/04
Isso recodifica, reduzindo a qualidade. Veja minha resposta se você quiser preservar a qualidade do arquivo. A recodificação não é necessária se o seu player suportar a marcação de volume.
Wil
11
usar sox em um lote que você pode usarfor f in *.mp3; do sox --norm "$f" /tmp/sox.mp3; mv -v /tmp/sox.mp3 "$f"; done
rubo77 27/09
30

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.

Philippe Gachoud
fonte
11
Além disso, se você não quiser usar o terminal, há uma GUI disponível para ele, chamada easymp3gain-gtk, que o torna muito útil!
precisa
Isso é super útil. Fiquei muito impressionado com a qualidade da normalização usando a GUI do MP3Gain para Windows, então fiquei feliz em encontrar essa resposta quando precisava de uma solução de linha de comando do Linux. Queremos definitivamente recomendar para os outros.
Alex P. Miller
Você poderia adicionar algumas informações sobre como instalá-lo? Por padrão, ele não vem com o Ubuntu e não consigo encontrar o pacote.
Błażej Michalik
Obrigado ... instalado python-rgain sem erros de dependência no Ubuntu 16.04.
Bharat Mallapur
instalar commkdir mp3gain; cd mp3gain; wget https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/mp3gain/1.5.2-r2-6/mp3gain_1.5.2-r2.orig.tar.gz; tar -xvzf mp3gain_1.5.2-r2.orig.tar.gz; make; sudo make install
rubo77 27/09
14

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.

sean_m
fonte
O OP quer instruções para fazer isso. Você pode fornecer isso?
Seth
@iSeth Eu estava inicialmente incorreto sobre o único comentário da fonte, porque não consegui encontrá-lo com a pesquisa do apt-cache. Eu atualizei com detalhes sobre o pacote deb.
sean_m
Esta parece ser uma boa alternativa, mas não consegue encontrar o codificador correto e se livrar de "nenhum codificador disponível" . Tentou com libsox-fmt-mp3, libavcodec-extra. -b *.mp3faça algo com apenas um arquivo (aleatório?).
Pablo A
4

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

Pablo A
fonte
3

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.

Neil
fonte
0

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()
Igor Stoppa
fonte