Como normalizar o som em arquivos mp3

38

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. Quais são as maneiras de fazer isso para todos os arquivos? Eu especialmente gostaria de fazê-lo através do terminal, mas as formas GUI também são aceitas.

    
por Luis Alvarado 22.01.2013 / 18:59

6 respostas

22

Audacity

ComoAudacity,podemosfacilmenteusararquivos processo em lote para aplicar conversões ou efeitos a muitos arquivos em uma lista. Para fazer isso, primeiro temos que definir um "Chain" contendo os efeitos que queremos aplicar.

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

Emseguida,escolhaoefeitoeseusparâmetrosparainserirnacadeia(mostradosaquiparaosvalorespadrãoeoefeitoNormalizar).

Important:wealwaysneedtoalsoaddtheeffect"Export MP3" (or any other export format) for saving the resulting conversion to disk.

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

Osarquivosprocessadosserãosalvosemumnovosubdiretório"limpo" no caminho do original.

Sox

Daversão>14.3podemosusarofiltrosox--normparanormalizaráudionalinhadecomandoouparaprocessamentoemlote:

sox--norminfileoutfile

OsuporteaMP3éadicionadoaoSoxcom libsox-fmt-all .

    
por Takkat 22.01.2013 / 19:36
29

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

mp3gain -r *.mp3

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

mp3gain -c -r *.mp3

como dito na man page:

O

mp3gain não apenas faz a normalização de pico, como muitos normalizadores fazem. Em vez disso, faz algumas análises estatísticas para determinar o quão alto o arquivo realmente soa ao ouvido humano. Além disso, as mudanças        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 decodificação e recodificação.

Observação : esse pacote foi removido de propósito no Ubuntu 15.04.

O Debian propõe o pacote python-rgain como substituto (A vantagem é que o 'replaygain' suporta vários formatos de arquivo, como o Ogg Vorbis, Flac, WavPack e MP3. Além disso, permite visualizar informações existentes do Replay Gain em qualquer um desses tipos de arquivo). Depois de instalá-lo, execute replaygain .

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

sudo apt-get install python-rgain

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

    
por Philippe Gachoud 27.09.2013 / 14:02
14

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

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

    
por sean_m 22.01.2013 / 19:09
4

repique novamente

Mais rápido e fácil replaygain :

This package provides a Python package to calculate the Replay Gain values of audio files and normalize the volume of those files according to the values. Two basic scripts exploiting these capabilities are shipped as well.

Replay Gain is a proposed standard designed to solve the very problem of varying volumes across audio files.

Instale: sudo apt install python-rgain .

replaygain --force *.mp3
  • -f, --force Recalcular Replay Ganho mesmo que o arquivo já contenha informações de ganho.

Como apenas calcular / alterar o valor da repetição, também é mais rápido: com um PC médio (Intel i7-6500U, 8GB de RAM), a taxa era de ~ 20 arquivos / minuto.

Referência

por Pablo Bianchi 22.03.2017 / 21:01
3

Por causa disso, vou jogar meus 2 centavos. Eu estava procurando exatamente a mesma coisa (apenas para arquivos ogg) e comecei 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 como quiser, chamei o db_adjust_mp3), chmod + x e coloque-o na pasta ~ / bin. Ele preenche todos os dados de codec ausentes. 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

Eu modifiquei o script para usar normalize-mp3 aqui para que você possa usá-lo se quiser:

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

Este script calcula a diferença entre o nível atual do banco de dados e -12db e, em seguida, aplica um ajuste de ganho para colocar o ganho exatamente em -12db, que é o que eu acho que funciona melhor para mim. Ele também é recursivo, o que o torna excelente para fazer coleções de músicas inteiras ou arquivos em muitas subpastas. Se você deseja definir um nível de banco de dados diferente, basta alterar as duas instâncias do número "12" para qualquer nível de banco de dados que você gostaria de usar. Como eu postei no meu thread Crunchbang, o uso é o seguinte:

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

No entanto, quando eu costumava manter minha biblioteca de músicas em formato mp3, eu costumava usar mp3gain também, assim como Philippe sugeriu. A simplicidade morta é ótima e eu realmente gostei. O problema com o áudio normalizado é que ele decodifica um re-endcode dos arquivos, portanto, há alguma degradação de som. Mas a menos que você seja um audiófilo e seus mp3 sejam codificados com uma alta taxa de bits, você não deve notar muita diferença.

A coisa que eu notei com o mp3gain foi que não importava as opções que eu tentei, eu não consegui fazer com que tudo na minha coleção fosse exatamente o mesmo nível do db, que é o que eu quero para que eu nunca precise ajustar o volume uma pista para a próxima. Este script faz exatamente isso. Desculpe por ser tão longo. Espero que isso ajude.

    
por Neil 20.10.2013 / 13:18
0

Eu gostei mais da resposta de Neil, porque ela não apresenta correlação entre os 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 de normalize-ogg com alguns arquivos que eu tenho. Há também um problema desagradável com bc : ele não faz arredondamento real, apenas trunca.

Então, acabei desistindo dos scripts de shell e mudei para python.

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

Nota2: isto irá sobrescrever 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 seguro.

Nota3: esta solução lida com arquivos ogg, mas é trivial para adaptá-lo para mp3, basta substituir as ocorrências de "ogg" com "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()
    
por Igor Stoppa 23.04.2017 / 17:48

Tags