Estoy buscando una manera de normalizar el sonido en MUCHOS archivos MP3 que tengo. Algunos tienen un sonido bajo, mientras que otros son más fuertes, así que tengo que subir o bajar el volumen según la canción. ¿Qué formas hay de hacer esto para todos los archivos? Especialmente me gustaría hacerlo a través del terminal, pero también se aceptan formas GUI.

Audacia

Con Audacity podemos procesar fácilmente archivos por lotes para aplicar conversiones o efectos a muchos archivos en una lista. Para hacerlo, primero tenemos que definir una "Cadena" que contenga los efectos que queremos aplicar.

Esto se hace con "Archivo -> Editar cadenas ..." . En la ventana que se abre ahora, presione el botón Agregar en la parte inferior izquierda para insertar una nueva cadena (asígnele un nombre razonable):

Luego, elija el efecto y sus parámetros para insertar en la cadena (aquí se muestran los valores predeterminados y el efecto Normalizar).

Importante: siempre necesitamos agregar también el efecto "Exportar MP3" (o cualquier otro formato de exportación) para guardar la conversión resultante en el disco.

Cuando termine, deje esta ventana con Aceptar para abrir "Archivo -> Aplicar cadena ..." . Seleccione la Cadena que acabamos de crear y cargue todos los archivos que necesite con "Aplicar a archivos ..." . Se pueden seleccionar varios archivos del selector de archivos que se abre.

Los archivos procesados ​​se guardarán en un nuevo subdirectorio "limpiado" en la ruta del original.

SoX

Desde la versión> 14.3 podemos usar el filtro sox --normpara normalizar el audio en la línea de comando o para el procesamiento por lotes:

sox --norm infile outfile

El soporte de MP3 se agrega a Sox con libsox-fmt-all:

sudo apt install sox libsox-fmt-all

Echa un vistazo @ mp3gain, que para mí es incluso mejor que normalizar audio

mp3gain -r *.mp3

otra versión útil podría ser la -c que evita preguntar si desea hacer los cambios para muchos archivos:

mp3gain -c -r *.mp3

como se dice en la página del manual:

mp3gain no solo hace la normalización máxima, como lo hacen muchos normalizadores. En cambio, realiza un análisis estadístico para determinar qué tan alto suena realmente el archivo para el oído humano. Además, los cambios que realiza mp3gain son completamente sin pérdidas. No se pierde calidad en el cambio porque el programa ajusta el archivo mp3 directamente, sin decodificar y volver a codificar.

Nota : Ese paquete se eliminó a propósito en ubuntu 15.04.

Debian propone el python-rgainpaquete como reemplazo (la ventaja es que 'replaygain' admite varios formatos de archivo, a saber, Ogg Vorbis, Flac, WavPack y MP3. Además, le permite ver la información existente de Replay Gain en cualquiera de esos tipos de archivos). Después de instalarlo, ejecute replaygain.

Para instalar python-rgain desde la terminal, ejecute el comando

sudo apt-get install python-rgain

Alternativamente, obtenga el .debarchivo para 14.04 (la última) desde aquí . Instalar como de costumbre. Después de eso, debe ejecutar sudo apt-get -f installpara corregir algunos problemas de dependencias.

Usaría este proyecto Normalizar , es una herramienta de línea de comandos para normalizar archivos de audio. Parece ser exactamente lo que necesitas. Puede hacer procesamiento por lotes y no requiere remuestreo a formatos intermedios.

Es en los repositorios de paquetes como normalizar audio, sudo apt-get install normalize-audio. Esta es una compilación mantenida corriente arriba por Debian, por lo que debería estar en cualquier versión LTS o más reciente y está construida con compatibilidad mp3 (probada). Hay una buena página de manual man normalize-audiopara explorar las opciones, pero los valores predeterminados de los comandos parecen funcionar bien. Para el procesamiento por lotes (normalice el volumen en varios archivos) normalize-audio -b *.mp3o especifique nombres de archivos individuales en lugar de usar comodines.

volver a ganar

Más rápido y fácil replaygain:

Este paquete proporciona un paquete de Python para calcular los valores de ganancia de reproducción de los archivos de audio y normalizar el volumen de esos archivos de acuerdo con los valores. También se envían dos scripts básicos que explotan estas capacidades.

Replay Gain es un estándar propuesto diseñado para resolver el problema mismo de variar los volúmenes en los archivos de audio.

Instalar: sudo apt install python-rgain.

replaygain --force *.mp3

• -f, --force Vuelva a calcular la ganancia de reproducción incluso si el archivo ya contiene información de ganancia.

Dado que solo calcular / cambiar el valor de recuperación, también es más rápido: con una PC promedio (Intel i7-6500U, 8GB de RAM) la velocidad fue de ~ 20 archivos / minuto.

Referencia

• Artículo ReplayGain en Wikipedia
• python-rgain en Launchpad

Por el bien, arrojaré mis 2 centavos. Estaba buscando exactamente lo mismo (solo para archivos ogg) y comencé un hilo en Crunchbang Forum. Puede verlo aquí: Normalize-audio no puede encontrar el decodificador de mp3

Básicamente mi solución fue el script en la publicación # 8. Funciona para archivos de entrada mp3, flac y ogg, posiblemente otros, pero definitivamente no wav.

Simplemente cree un archivo (asígnele el nombre que desee, llamé el mío db_adjust_mp3), chmod + x, y péguelo en su carpeta ~ / bin. También completa los datos de códec que faltan. Ejemplo:

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

vs.

Archivo 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

He modificado el script para usar normalize-mp3 aquí para que pueda usarlo si lo desea:

#!/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 la diferencia entre el nivel de db actual y -12db, luego aplica un ajuste de ganancia para poner la ganancia exactamente en -12db, que es lo que he encontrado que funciona mejor para mí. También es recursivo, lo que lo hace ideal para hacer colecciones completas de música o archivos en muchas subcarpetas. Si desea establecer un nivel de base de datos diferente, simplemente cambie las dos instancias del número "12" a cualquier nivel de base de datos que le gustaría usar. Como publiqué en mi hilo Crunchbang, el uso es el siguiente:

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

Sin embargo, cuando solía mantener mi biblioteca de música en formato mp3, también solía usar mp3gain, tal como sugirió Philippe. La simplicidad muerta es genial y realmente me gustó. Sin embargo, el problema con normalizar audio es que decodifica y vuelve a codificar los archivos, por lo que hay una degradación del sonido. Pero a menos que sea un audiófilo y sus mp3 estén codificados a una tasa de bits alta, no debería notar mucha diferencia.

Sin embargo, lo que noté con mp3gain fue que, sin importar las opciones que probé, no podía hacer que todo en mi colección tuviera exactamente el mismo nivel de db, que es lo que quiero para que nunca tenga que ajustar el volumen de una pista a el siguiente. Este script hace exactamente eso. Perdón por estar tanto tiempo sin aliento. Espero que esto ayude.

La respuesta de Neil me gustó más, porque no introduce correlación entre los archivos de audio: solo elija un nivel de ganancia y ajuste todo a él.

Sin embargo, tuve algunos problemas al analizar la salida de normalize-oggalgunos archivos que tengo. También hay un problema desagradable con bc: no hace un redondeo real, solo se trunca.

Así que finalmente renuncié a las secuencias de comandos de shell y me mudé a Python.

Nota 1: la parte exiftool podría ser exagerada, pero quería estar 100% seguro de que se conservaría la tasa de bits original.

Nota 2: esto sobrescribirá los originales, si desea conservarlos, use --backup en la última llamada para normalizar-ogg. Pero me pareció más práctico mantener una copia en un directorio separado y más seguro.

Nota 3: esta solución trata con archivos ogg, pero es trivial adaptarlo a mp3, simplemente reemplace las ocurrencias de "ogg" con "mp3".

Aquí está mi opinión sobre el problema. La última versión se puede encontrar aquí: 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()