¡Revisa la salud de tus MP3!!

No es nada extraño en una radio tener colecciones de música en MP3 de varios gigas, tampoco es nada fuera de lo común que no sepamos la procedencia de esos archivos, y más probable aún es que al revisar el estado de los mismos nos encontremos con sorpresas desagradables.

Pero lo peor que nos puede pasar, es que en momentos que no haya personal y la radio esté funcionando en automático, de pronto el automatizador quede bloqueado y en silencio hasta que alguien se dé cuenta. Muchas veces esto no se debe a un bug o problema del automatizador, el culpable puede ser un MP3 mal formado o corrupto.

Para evitar esto podemos recurrir a la herramienta mp3val, disponible en los repositorios de la mayoría de las distros GNU/Linux y para usar esta herramienta crearemos un script para usarlo desde la terminal en cualquier directorio.

Antes de ponernos manos a la obra veamos que es lo que revisa el script.

Estructura del Archivo MP3

• Cabeceras de frames (headers) válidas
• Sincronización de bits correcta
• Estructura de frames consistente
• IDs de tag (ID3v1, ID3v2) válidos

Decodificación del Audio

• El archivo puede ser decodificado completamente
• No hay frames corruptos o ilegibles
• El stream de audio es continuo sin interrupciones críticas

Consistencia de Metadatos

• Tags ID3 bien formados
• Información de bitrate consistente
• Tasa de muestreo válida

El script nos indicará dos tipos de posibles problemas:

PROBLEMAS CRÍTICOS (archivo marcado como ✗ (corrupto)

• Frames corruptos que impiden reproducción
• Cabeceras de frame inválidas
• Archivo truncado/incompleto
• Formato no reconocido como MP3
• Errores de sincronización graves

ADVERTENCIAS (archivo marcado como ⚠)

• Bitrate variable inconsistente
• Tags ID3 con problemas menores
• Frames descartables
• Información de duración imprecisa

En resumen: El script te dice si el archivo MP3 está técnicamente bien formado y se puede reproducir, pero no evalúa la calidad auditiva ni el contenido específico del audio.

Bien, lo primero es ver que tengamos las dependencias necesarias en el sistema, para eso logueate en una terminal como root, si estás en cualquier versión de EterTICs escribe:

su

Y luego:

apt install mp3val ffmpeg

En otras distros:

sudo apt install mp3val ffmpeg

1- Una vez tengas las herramientas instaladas vamos a crear el script, abre una terminal para crear el archivo:

nano revisar-mp3.sh

Pega en el archivo de nano vacio el contenido del script de abajo y guarda el script con Ctrl+o

#!/bin/bash

# Script para verificar integridad de archivos MP3, eliminar corruptos y generar reporte
# SIN generar archivos .bak de respaldo
# Uso: ./verificar_mp3.sh [directorio] [-d|--delete] [-f|--force] [-r|--report]

# Colores para output
ROJO='\033[0;31m'
VERDE='\033[0;32m'
AMARILLO='\033[1;33m'
AZUL='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Contadores
TOTAL=0
VALIDOS=0
INVALIDOS=0
ADVERTENCIAS=0
ELIMINADOS=0
FALLIDOS_ELIMINAR=0

# Opciones
ELIMINAR=false
FORZAR=false
GENERAR_REPORT=true
DIRECTORIO="."
ARCHIVO_REPORT=""

# Función para mostrar uso
mostrar_uso() {
    echo -e "${AZUL}Uso:${NC} $0 [directorio] [opciones]"
    echo ""
    echo -e "${CYAN}Opciones:${NC}"
    echo "  -d, --delete     Eliminar archivos corruptos automáticamente"
    echo "  -f, --force      Eliminar sin pedir confirmación"
    echo "  -r, --report     Generar reporte CSV (por defecto: activado)"
    echo "  --no-report      No generar reporte"
    echo "  -h, --help       Mostrar esta ayuda"
    echo ""
    echo -e "${CYAN}Ejemplos:${NC}"
    echo "  $0 /musica/mp3"
    echo "  $0 /musica/mp3 -d"
    echo "  $0 /musica/mp3 -d -f"
    exit 1
}

# Función para verificar herramientas
verificar_herramientas() {
    if command -v mp3val &> /dev/null; then
        HERRAMIENTA="mp3val"
        echo -e "${VERDE}✓${NC} Usando mp3val para verificación (modo solo lectura)"
    elif command -v ffmpeg &> /dev/null; then
        HERRAMIENTA="ffmpeg"
        echo -e "${AMARILLO}⚠${NC} Usando ffmpeg como alternativa (mp3val no encontrado)"
    else
        echo -e "${ROJO}✗${NC} Error: Necesitas instalar mp3val o ffmpeg"
        echo -e "  Ubuntu/Debian: sudo apt install mp3val ffmpeg"
        echo -e "  Fedora/RHEL: sudo dnf install mp3val ffmpeg"
        exit 1
    fi
}

# Función para verificar con mp3val (SIN -f para no crear .bak)
verificar_con_mp3val() {
    local archivo="$1"
    local resultado
    
    # NOTA: Sin la opción -f, mp3val solo verifica, no repara ni crea backups
    resultado=$(mp3val "$archivo" 2>&1)
    
    if echo "$resultado" | grep -q "ERROR"; then
        return 2
    elif echo "$resultado" | grep -q "WARNING"; then
        return 1
    else
        return 0
    fi
}

# Función para verificar con ffmpeg
verificar_con_ffmpeg() {
    local archivo="$1"
    
    ffmpeg -v error -i "$archivo" -f null - 2>/dev/null
    return $?
}

# Función para eliminar archivo
eliminar_archivo() {
    local archivo="$1"
    local nombre=$(basename "$archivo")
    
    if [ "$FORZAR" = true ]; then
        if rm -f "$archivo" 2>/dev/null; then
            echo -e "${MAGENTA}🗑️${NC} $nombre ${VERDE}(eliminado)${NC}"
            ((ELIMINADOS++))
            return 0
        else
            echo -e "${MAGENTA}🗑️${NC} $nombre ${ROJO}(falló eliminación)${NC}"
            ((FALLIDOS_ELIMINAR++))
            return 1
        fi
    else
        echo -ne "${MAGENTA}¿Eliminar $nombre?${NC} [s/N]: "
        read -r respuesta
        if [[ "$respuesta" =~ ^[Ss]$ ]]; then
            if rm -f "$archivo" 2>/dev/null; then
                echo -e "  ${VERDE}✓ Eliminado${NC}"
                ((ELIMINADOS++))
                return 0
            else
                echo -e "  ${ROJO}✗ Falló eliminación${NC}"
                ((FALLIDOS_ELIMINAR++))
                return 1
            fi
        else
            echo -e "  ${AMARILLO}⚠ Omitido${NC}"
            return 1
        fi
    fi
}

# Función principal de verificación
verificar_archivo() {
    local archivo="$1"
    local nombre=$(basename "$archivo")
    local estado=0
    local razon=""
    
    ((TOTAL++))
    
    # Verificar integridad
    if [ "$HERRAMIENTA" = "mp3val" ]; then
        verificar_con_mp3val "$archivo"
        estado=$?
    else
        verificar_con_ffmpeg "$archivo"
        estado=$?
    fi
    
    # Determinar mensaje según estado
    case $estado in
        0)
            echo -e "${VERDE}✓${NC} $nombre"
            ((VALIDOS++))
            razon="OK"
            ;;
        1)
            echo -e "${AMARILLO}⚠${NC} $nombre (advertencias menores)"
            ((ADVERTENCIAS++))
            ((VALIDOS++))
            razon="ADVERTENCIA"
            ;;
        2|*)
            echo -e "${ROJO}✗${NC} $nombre (CORRUPTO o inválido)"
            ((INVALIDOS++))
            razon="CORRUPTO"
            
            # Eliminar si está activado
            if [ "$ELIMINAR" = true ]; then
                eliminar_archivo "$archivo"
            fi
            ;;
    esac
    
    # Guardar en reporte
    if [ "$GENERAR_REPORT" = true ]; then
        echo "$archivo,$nombre,$estado,$razon,$(date +%Y-%m-%d_%H:%M:%S)" >> "$ARCHIVO_REPORT"
    fi
}

# Función para generar reporte CSV
generar_reporte() {
    if [ "$GENERAR_REPORT" = false ]; then
        return
    fi
    
    local CSV_FILE="reporte_mp3_$(date +%Y%m%d_%H%M%S).csv"
    
    # Crear cabecera
    echo "ruta_archivo,nombre_archivo,estado,razon,fecha_verificacion" > "$CSV_FILE"
    
    # Copiar datos del reporte temporal
    if [ -f "$ARCHIVO_REPORT" ]; then
        cat "$ARCHIVO_REPORT" >> "$CSV_FILE"
        rm -f "$ARCHIVO_REPORT"
    fi
    
    echo ""
    echo -e "${CYAN}════════════════════════════════════════${NC}"
    echo -e "${CYAN}📄 Reporte generado:${NC} $CSV_FILE"
    echo -e "${CYAN}════════════════════════════════════════${NC}"
}

# =====================
# PROGRAMA PRINCIPAL
# =====================

# Parsear argumentos
while [[ $# -gt 0 ]]; do
    case $1 in
        -d|--delete)
            ELIMINAR=true
            shift
            ;;
        -f|--force)
            FORZAR=true
            shift
            ;;
        -r|--report)
            GENERAR_REPORT=true
            shift
            ;;
        --no-report)
            GENERAR_REPORT=false
            shift
            ;;
        -h|--help)
            mostrar_uso
            ;;
        -*)
            echo -e "${ROJO}✗${NC} Opción desconocida: $1"
            mostrar_uso
            ;;
        *)
            DIRECTORIO="$1"
            shift
            ;;
    esac
done

# Verificar directorio
if [ ! -d "$DIRECTORIO" ]; then
    echo -e "${ROJO}✗${NC} Error: El directorio '$DIRECTORIO' no existe"
    exit 1
fi

# Crear archivo de reporte temporal
if [ "$GENERAR_REPORT" = true ]; then
    ARCHIVO_REPORT="/tmp/mp3_report_$$.tmp"
    > "$ARCHIVO_REPORT"
fi

# Verificar herramientas
verificar_herramientas

echo -e "${AZUL}════════════════════════════════════════${NC}"
echo -e "${AZUL}Verificando archivos MP3 en:${NC} $DIRECTORIO"
echo -e "${AZUL}════════════════════════════════════════${NC}"
echo -e "${CYAN}Eliminar corruptos:${NC} $([ "$ELIMINAR" = true ] && echo -e "${VERDE}SÍ${NC}" || echo -e "${AMARILLO}NO${NC}")"
echo -e "${CYAN}Confirmación:${NC} $([ "$FORZAR" = true ] && echo -e "${AMARILLO}DESACTIVADA${NC}" || echo -e "${VERDE}ACTIVADA${NC}")"
echo -e "${CYAN}Generar reporte:${NC} $([ "$GENERAR_REPORT" = true ] && echo -e "${VERDE}SÍ${NC}" || echo -e "${AMARILLO}NO${NC}")"
echo -e "${CYAN}Crear backups .bak:${NC} ${AMARILLO}NO${NC}"
echo -e "${AZUL}════════════════════════════════════════${NC}"
echo ""

# Buscar y verificar archivos MP3
while IFS= read -r -d '' archivo; do
    verificar_archivo "$archivo"
done < <(find "$DIRECTORIO" -type f \( -iname "*.mp3" -o -iname "*.MP3" \) -print0 2>/dev/null | sort -z)

# Mostrar resumen
echo ""
echo -e "${AZUL}════════════════════════════════════════${NC}"
echo -e "${AZUL}RESUMEN:${NC}"
echo -e "${AZUL}════════════════════════════════════════${NC}"
echo -e "Total archivos:        $TOTAL"
echo -e "${VERDE}Válidos:              $VALIDOS${NC}"
echo -e "${AMARILLO}Con advertencias:     $ADVERTENCIAS${NC}"
echo -e "${ROJO}Inválidos/Corruptos:  $INVALIDOS${NC}"

if [ "$ELIMINAR" = true ]; then
    echo -e "${MAGENTA}Eliminados:           $ELIMINADOS${NC}"
    if [ $FALLIDOS_ELIMINAR -gt 0 ]; then
        echo -e "${ROJO}Fallidos eliminación: $FALLIDOS_ELIMINAR${NC}"
    fi
fi

echo ""

# Generar reporte
generar_reporte

# Código de salida
if [ $INVALIDOS -gt 0 ]; then
    if [ "$ELIMINAR" = true ] && [ $ELIMINADOS -eq $INVALIDOS ]; then
        echo -e "${VERDE}✓ Todos los archivos corruptos fueron eliminados${NC}"
        exit 0
    else
        echo -e "${ROJO}⚠ Se encontraron archivos corruptos${NC}"
        exit 1
    fi
else
    echo -e "${VERDE}✓ Todos los archivos están en buen estado${NC}"
    exit 0
fi

2- Ahora vamos a facilitar su posterior uso, abre una nueva terminal y como superusuario o root segun sea el caso, escribe:

sudo cp revisar-mp3.sh /usr/local/bin/revisar-mp3

Le damos permisos con:

sudo chmod +x /usr/local/bin/revisar-mp3

Ahora ya podemos correrlo en cualquier directorio, simplemente abriendo una terminal en el directorio donde tenemos los MP3 y escribiendo:

revisar-mp3

Esto realizará el chequeo en el directorio donde abrimos la terminal y todos sus subdirectorios, nos informará si hay archivos corruptos o con advertencias, no elimina nada.
Además, va a generar un informe en CSV dentro del directorio.

Para eliminar los archivos corruptos corre el comando de la siguiente manera:

revisar-mp3 -d -f

Esto eliminará los corruptos sin pedir confirmación, luego en el archivo de reporte puedes ver cuáles fueron eliminados para volver a conseguirlos en buen estado. Nota los archivos marcados con advertencias no impiden ser usados ni generan problemas.

Si lo prefieres puedes descargar el archivo tar.gz con el script ya listo a tu home, lo descomprimes y continuas con el paso 2.

Tómate tu tiempo y chequea todos los MP3 que usas en la radio, tu software automatizador y tus oyentes lo agradecerán.

Para terminar te dejo un video de apoyo para que veas el proceso.