MP3 Balance (MP3 Баланс): как да изравниш силата на звука на MP3 файловете

Python скрипт с графичен интерфейс, който изравнява силата на звука на MP3 файлове чрез двупроходен ffmpeg loudnorm, с пресети, анализ, резервни копия и почистване на имена.

Прозорецът на MP3 Balance – инструмент за нормализиране на силата на звука на MP3 файлове

Имам доста голяма музикална колекция, събрана от различни места и в различни години. Някои песни свирят тихо, други те удрят по ушите, и при плейлист в разбъркан ред ръката ми постоянно е на копчето за звука. Това е досадно и е напълно решим проблем.

Затова написах (и многократно подобрявах) един малък инструмент, който нарекох MP3 Balance (на български – MP3 Баланс). В тази статия ще обясня какво прави, как работи отвътре, как се ползва и какво трябва да знаеш, преди да го пуснеш върху цяла колекция. Накрая ще намериш и целия скрипт.

Какъв проблем решава MP3 Balance

Когато казвам „силата на звука“ на един файл, имам предвид не максималната амплитуда, а възприеманата сила (loudness). Тя се измерва в LUFS (Loudness Units relative to Full Scale) по стандарта EBU R128 (в основата му е ITU-R BS.1770). Две песни могат да имат един и същ пик, а да звучат с коренно различна сила.

Какво ме интересува при една нормализация:

  • Integrated loudness (I) – средната възприемана сила на целия файл, в LUFS.
  • True Peak (TP) – най-високият реален пик, в dBTP. Ако е твърде висок, при кодиране или възпроизвеждане може да се получи клипинг.
  • Loudness Range (LRA) – колко голяма е динамиката на записа.

Скриптът довежда всеки файл до избрана целева сила, като същевременно пази пика под зададен таван.

Защо ffmpeg loudnorm и защо два прохода

Не измислям нищо ново. Използвам филтъра loudnorm на ffmpeg, който реализира EBU R128. Той може да работи в един проход (динамично), но тогава коригира силата „в движение“ и може да промени динамиката на песента.

По-добрият вариант е двупроходен:

  1. Първи проход – ffmpeg само измерва файла (I, TP, LRA, threshold, offset) и връща резултата като JSON.
  2. Втори проход – подавам тези измервания обратно на loudnorm с linear=true. Така се прилага почти чисто линейно усилване или намаление, без да се „гнети“ динамиката.

Ако измерването не върне валидни данни (например при безшумен или повреден запис), скриптът не рискува и минава на динамичен режим в един проход. В лога това се вижда ясно.

Какво умее MP3 Balance

Ето основното, накратко:

  • Графичен интерфейс на customtkinter – тъмна тема, прогрес, цветен лог.
  • Пресети за Spotify/YouTube, Apple Music, Deezer, Amazon Music и EBU R128, плюс персонализирани стойности.
  • Режим „Само анализ“ – измерва и записва CSV отчет, без да пипа файловете.
  • Пропускане на вече нормализирани файлове (в рамките на ±0.5 LU), за да не се прекодират излишно.
  • Резервни копия на оригиналите в папка _originals.
  • Запазване на обложката (-c:v copy) – без прекодиране на картинката.
  • Запазване на честотата на дискретизация на оригинала (48 kHz остава 48 kHz).
  • Предупреждение при занижаване на битрейта спрямо оригинала.
  • Почистване на имена от „социални“ боклуци като „53K views · 2K reactions“.
  • Коректно спиране – прекъсва ffmpeg веднага, оригиналът остава непроменен, временните файлове се трият.
  • Автоматично търсене на ffmpeg и запомняне на настройките между стартиранията.

Пресети

Пресет Цел (LUFS) True Peak (dBTP) LRA
Spotify / YouTube −14 −1.0 11
Apple Music −16 −1.0 11
Deezer −15 −1.0 11
Amazon Music −14 −2.0 11
Радио / EBU R128 −23 −1.0 9

При „Персонализирано…“ скриптът приема само стойности в границите, които самият loudnorm допуска: I от −70 до −5, TP от −9 до 0, LRA от 1 до 50. Ако въведеш нещо извън тях, получаваш предупреждение, а не мълчалива грешка.

За ежедневно слушане в колата или на слушалки аз лично се придържам към −14 LUFS, но това е въпрос на вкус и на това къде слушаш.

Инсталация

Нужни са Python 3.9+ и ffmpeg.

pip install customtkinter

По желание, ако искаш скриптът да чисти заглавието (Title) в тага и при файловете, които пропуска:

pip install mutagen

После го стартираш така:

python mp3_balance.py

Съвет за Windows: преименувай файла на mp3_balance.pyw, за да се стартира изобщо без черен конзолен прозорец.

Къде да сложиш ffmpeg

Скриптът сам търси ffmpeg в PATH, в C:\ffmpeg, в папките на Program Files, в WinGet и до самия скрипт. Ако не го намери, в долната лента пише, че ffmpeg липсва. Кликваш върху нея и посочваш ffmpeg.exe ръчно. Пътят се запомня.

Как го ползвам стъпка по стъпка

  1. Избирам папката с MP3 файлове (с опция за подпапките).
  2. Избирам пресет и битрейт.
  3. Първо пускам „Само анализ“. Получавам CSV отчет с измерената сила, пика, LRA и нужната корекция за всеки файл.
  4. Разглеждам отчета и после превключвам на „Нормализиране“.
  5. Натискам „Стартирай обработката“ и следя лога.

Препоръчвам да не прескачаш стъпка 3 при голяма колекция. Така виждаш какво ще се промени, преди да се промени.

Какво съдържа CSV отчетът

Отчетът е с разделител ; и кодировка UTF-8 с BOM, така че се отваря правилно в Excel. Колоните са:

  • файл;
  • сила (LUFS);
  • пик (dBTP);
  • LRA;
  • целева сила;
  • нужна корекция (dB);
  • битрейт на източника (kbps);
  • предложено чисто име.

Безопасност: какво се случва с оригиналите ми

Най-много внимание отделих тъкмо на това, защото колекцията е трудно възстановима.

  • Обработеният файл първо се записва като временен (с маркер .normtmp- в името), а не върху оригинала.
  • Ако е включено резервно копие, оригиналът се копира в _originals със запазена структура на подпапките. Ако копието не успее, оригиналът не се пипа.
  • Замяната се прави с os.replace, което е атомарна операция. Ако файлът е зает (например се възпроизвежда), скриптът прави няколко повторни опита.
  • При натискане на „Спри“ текущият ffmpeg процес се прекъсва, временният файл се изтрива, а оригиналът остава такъв, какъвто е.
  • При следващо сканиране остатъчните временни файлове от прекъсната работа се чистят автоматично.

Почистване на имена от „социални“ отпадъци

Файловете, свалени от социални мрежи, често идват с имена като 53K views · 2K reactions - Песен. Опитах да направя нещо по-умно от обикновено заместване. Скриптът разпознава с регулярни изрази:

  • броячи с „views“, „reactions“, „comments“, „shares“, „likes“ и техните български аналози („прегледа“, „реакции“, „коментара“, „споделяния“, „харесвания“, „слушания“);
  • време от рода на „3 days ago“ или „преди 3 дни“;
  • фрази като „Original audio“ или „Оригинален звук“;
  • връзки (http://, www., fb.watch/).

Освен това можеш да добавиш собствени текстове за премахване (до 20, разделени със запетая). Резултатът минава през безопасно име за файловата система: без забранените за Windows знаци и без точка или интервал в края.

Две предпазни мерки, които държа да спомена:

  • Ако след изчистването не остане нищо, скриптът връща оригиналното име, за да не остане файлът без име.
  • Ако вече има файл с новото име, към него се добавя номер, например Песен (2).mp3. Нищо не се презаписва.

Чистенето на заглавието (Title) в тага става по два начина. При нормализираните файлове подавам новото заглавие директно на ffmpeg чрез -metadata. При пропуснатите файлове (които не се прекодират) се променят само метаданните, и то с библиотеката mutagen, ако е инсталирана. Аудио данните не се пипат.

Какво трябва да знаеш: ограничения и подводни камъни

Няма смисъл да се преструвам, че е перфектно. Ето какво е важно да имаш предвид.

  1. MP3 е формат със загуби. Всяка нормализация означава прекодиране, освен когато файлът се пропуска. Затова скриптът предупреждава, когато битрейтът на оригинала е сериозно над избрания. Ако оригиналът е на 320 kbps, не го прекодирай на 128.
  2. Върху вече прекодиран файл губиш допълнително качество. Ако имаш възможност, работи с по-висок битрейт.
  3. Целта на LUFS е компромис. Много тих запис с висока динамика може да не достигне целевата сила, без да удари тавана за пика. Тук линейният режим внимава с пика, а не го жертва.
  4. Пресетите не са закон. Стойностите отговарят на най-често цитираните препоръки за съответните платформи. Платформите ги променят, така че ако ти трябва точност, провери актуалните им спецификации.
  5. Тествай върху копие. Преди първото пускане върху цялата колекция опитай с няколко файла в отделна папка.
  6. Настройките се пазят във файл .mp3_balance.json в домашната ти папка.

Идеи за надграждане

Ако искаш да го разшириш, ето няколко посоки:

  • поддръжка на други формати (FLAC, M4A, OGG);
  • паралелна обработка на няколко файла;
  • ReplayGain тагове вместо прекодиране;
  • предварителен преглед на промените в таблица, преди да се пипне нещо.

Целият скрипт

Ето и самият код. Копирай го в файл mp3_balance.py (или .pyw) и го стартирай, както е описано по-горе.

Натисни тук, за да видиш скритото съдържание
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MP3 BALANCE (MP3 Баланс) — v2.3
===============================

Графичен инструмент за нормализиране на силата на звука на MP3 файлове
чрез ffmpeg (двупроходен loudnorm по EBU R128).

Какво е оправено и добавено спрямо старата версия:
  • БЕЗ изскачащи конзолни прозорци по време на обработка — при всяко
    извикване на ffmpeg под Windows се подават CREATE_NO_WINDOW +
    STARTF_USESHOWWINDOW (това беше причината за мигащите прозорци)
  • Автоматично търсене на ffmpeg (PATH, C:\\ffmpeg, winget, папката на
    скрипта) + ръчен избор с клик върху статус лентата — запомня се
  • Пресети: Spotify/YouTube, Apple Music, Deezer, Amazon, EBU R128
    + персонализирани стойности (LUFS / True Peak / LRA)
  • Почистване на имена от социални отпадъци — „53K views · 2K reactions“,
    „1,2 млн прегледа“, „преди 3 дни“, връзки и подобни — по избор и в
    заглавието (Title) в тага + собствени текстове за премахване
  • Режим „Само анализ“ — измерва без да променя и записва CSV отчет
    (в отчета се вижда и предложеното чисто име на всеки файл)
  • Пропускане на файлове, вече в норма (±0.5 LU) — без повторно
    прекодиране и без загуба на качество
  • Резервни копия на оригиналите в папка _originals
  • Обложката/корица се пренася бит-в-бит (−c:v copy) — преди това ffmpeg
    тихо я прекодираше в PNG и надуваше файла без причина
  • Честотата на оригинала се запазва (48 кГц остава 48 кГц); 44.1 кГц е
    само резерв при невалидна за MP3 входна честота
  • Явно предупреждение при занижаване на битрейта спрямо оригинала;
    битрейтът на източника се вижда и в CSV отчета
  • Граници на персонализираните параметри според самия ffmpeg loudnorm:
    I −70…−5 · TP −9…0 · LRA 1…50
  • Коректно спиране — ffmpeg се прекъсва веднага, оригиналът остава
    непроменен, временните файлове се изчистват
  • Реални съобщения за грешка от ffmpeg, повторни опити при зает файл
  • Оцветен лог + експорт във .txt; настройките се запомнят между
    стартиранията (последна папка, пресет, битрейт, размер на прозореца)

СТАРТИРАНЕ:
  1) pip install customtkinter
  2) python mp3_balance.py
  Съвет: преименувай файла на ...pyw, за да се пуска изобщо без черен
  конзолен прозорец на Windows.

Изисквания: Python 3.9+ и ffmpeg някъде на компютъра.
"""

from __future__ import annotations

import csv
import html
import json
import math
import os
import queue
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import time
import uuid
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from tkinter import filedialog, messagebox

try:
    import customtkinter as ctk
    GUI_AVAILABLE = True
except ImportError:
    GUI_AVAILABLE = False

# ====================== КОНСТАНТИ ======================

APP_NAME = "MP3 Balance"
APP_VERSION = "2.3"

SETTINGS_PATH = Path.home() / ".mp3_balance.json"

BACKUP_DIR_NAME = "_originals"   # резервните копия отиват тук (в избраната папка)
TEMP_MARK = ".normtmp-"          # маркер за временни файлове по време на работа
SKIP_TOLERANCE_LU = 0.5          # допустимо отклонение, за да смятаме файл за „в норма“
TP_TOLERANCE_DB = 0.2            # допустимо превишаване на True Peak при пропускане
REPLACE_RETRIES = 4              # повторни опити при зает файл (възпроизвеждане)
MP3_RATES = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000}

CUSTOM_LABEL = "Персонализирано..."

# (целената сила LUFS, максимален True Peak dBTP, Loudness Range LRA)
PRESETS = {
    "Spotify / YouTube   (I=-14, TP=-1.0, LRA=11)": (-14.0, -1.0, 11.0),
    "Apple Music   (I=-16, TP=-1.0, LRA=11)": (-16.0, -1.0, 11.0),
    "Deezer   (I=-15, TP=-1.0, LRA=11)": (-15.0, -1.0, 11.0),
    "Amazon Music   (I=-14, TP=-2.0, LRA=11)": (-14.0, -2.0, 11.0),
    "Радио / EBU R128   (I=-23, TP=-1.0, LRA=9)": (-23.0, -1.0, 9.0),
    CUSTOM_LABEL: None,
}

BITRATES = {
    "128 kbps": "128k",
    "192 kbps (препоръчително)": "192k",
    "256 kbps": "256k",
    "320 kbps (макс. качество)": "320k",
}

MODE_NORMALIZE = "Нормализиране"
MODE_ANALYZE = "Само анализ (без промяна)"

DEFAULT_SETTINGS = {
    "target_lufs": -14.0,
    "true_peak": -1.0,
    "lra": 11.0,
    "bitrate": "192k",
    "recursive": True,
    "backup": True,
    "skip_normalized": True,
    "clean_names": True,
    "clean_title_tag": True,
    "clean_patterns": "",
    "last_folder": "",
    "ffmpeg_path": "",
    "geometry": "",
}

# ============ Windows: потискане на конзолните прозорци ============

IS_WINDOWS = sys.platform.startswith("win")

if IS_WINDOWS:
    _CREATE_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
    _STARTUPINFO = subprocess.STARTUPINFO()
    _STARTUPINFO.dwFlags |= getattr(subprocess, "STARTF_USESHOWWINDOW", 0x00000001)
else:
    _CREATE_NO_WINDOW = 0
    _STARTUPINFO = None


def sp_kwargs() -> dict:
    """Допълнителни аргументи за subprocess — потискат изскачащите конзолни
    прозорци при всяко извикване на ffmpeg под Windows."""
    if IS_WINDOWS:
        return {"creationflags": _CREATE_NO_WINDOW, "startupinfo": _STARTUPINFO}
    return {}


# ====================== ПОМОЩНИ ФУНКЦИИ ======================

def fmt_sec(seconds: float) -> str:
    s = int(round(max(0.0, seconds)))
    h, rem = divmod(s, 3600)
    m, sec = divmod(rem, 60)
    return f"{h}:{m:02d}:{sec:02d}" if h else f"{m}:{sec:02d}"


def fmt_num(v, nd: int = 1) -> str:
    return "n/a" if v is None else f"{v:.{nd}f}"


def choose_sample_rate(src):
    """Запазва честотата на оригинала, ако е валидна за MP3; иначе 44.1 кГц.
    (Умишлено НЕ я насилваме към 44.1 — 48 кГц остава 48 кГц и т.н.)"""
    return src if src in MP3_RATES else 44100


def valid_custom_params(i: float, tp: float, lra: float) -> bool:
    """Границите, които ffmpeg loudnorm действително приема
    (ffmpeg -h filter=loudnorm): I −70…−5, TP −9…0, LRA 1…50."""
    return (-70.0 <= i <= -5.0) and (-9.0 <= tp <= 0.0) and (1.0 <= lra <= 50.0)


def load_settings() -> dict:
    s = dict(DEFAULT_SETTINGS)
    try:
        with open(SETTINGS_PATH, encoding="utf-8") as fh:
            data = json.load(fh)
        for k in s:
            if k in data:
                s[k] = data[k]
    except (OSError, ValueError):
        pass
    return s


def save_settings(s: dict) -> None:
    try:
        with open(SETTINGS_PATH, "w", encoding="utf-8") as fh:
            json.dump(s, fh, ensure_ascii=False, indent=2)
    except OSError:
        pass


def scan_mp3(folder: Path, recursive: bool) -> list:
    """Намира MP3 файловете. Изчиства остатъчни временни файлове от
    прекъсната обработка и прескача папката с резервни копия."""
    found = []
    for p in (folder.rglob("*") if recursive else folder.glob("*")):
        try:
            if not p.is_file() or p.suffix.lower() != ".mp3":
                continue
            if TEMP_MARK in p.name:                      # остатък от прекъснато изпълнение
                p.unlink(missing_ok=True)
                continue
            if BACKUP_DIR_NAME in p.relative_to(folder).parts:
                continue                                 # не пипаме резервните копия
            found.append(p)
        except OSError:
            continue
    return sorted(found)


# ============ ПОЧИСТВАНЕ НА ИМЕНА ОТ „СОЦИАЛНИ“ ОТПАДЪЦИ ============
# Файлове, изтеглени от социални мрежи, често носят имена като
# „53K views · 2K reactions - Песен“. Тези шаблони ги изчистват.

_MAG = r"(?:[KMКМБ]|хил\.?|млн\.?)?"
_SOCIAL_WORDS = (
    r"views?|reactions?|comments?|shares?|likes?|plays?|listenings?|streams?|"
    r"followers?|прегледа|прегледи|преглед|гледания|реакции|реакция|"
    r"коментара|коментари|коментар|споделяния|споделяне|харесвания|харесване|слушания"
)
JUNK_COUNT_RE = re.compile(
    rf"[·•|]?\s*\d+(?:[.,]\d+)?\s*{_MAG}\s*(?:{_SOCIAL_WORDS})\b[·•|]?\s*",
    re.IGNORECASE)
JUNK_AGO_RE = re.compile(
    r"[·•|]?\s*(?:\d+\s*(?:years?|months?|weeks?|days?|hours?|minutes?|seconds?|"
    r"hrs?|mins?|secs?)\s*ago|преди\s+\d+\s*(?:години|година|г\.|месеца|месец|"
    r"седмици|седмица|дни|ден|часа|час|минути|минута|секунди|секунда))[·•|]?\s*",
    re.IGNORECASE)
JUNK_PHRASE_RE = re.compile(
    r"[·•|]?\s*(?:original\s+(?:audio|sound|video)|оригинален\s+(?:звук|аудио)|"
    r"оригинално\s+аудио|оригиналният\s+звук)[·•|]?\s*", re.IGNORECASE)
JUNK_URL_RE = re.compile(r"(?:https?://\S+|www\.\S+|fb\.watch/\S+)", re.IGNORECASE)

_EMPTY_BRACKET_RE = re.compile(r'[([{]\s*[)\]}]')
_MULTI_SEP_RE = re.compile(r"(?:[ \t]*[-–—·•|][ \t]*){2,}")
_EDGE_SEP_RE = re.compile(r"^[ \t_·•.,;:|~–—-]+|[ \t_·•.,;:|~–—-]+$")
_WIN_BAD_RE = re.compile(r'[<>:"/\\|?*\x00-\x1f]')


def has_junk(text: str) -> bool:
    """Съдържа ли текстът поне един разпознат „социален“ отпадък?"""
    return any(rx.search(text) for rx in
               (JUNK_COUNT_RE, JUNK_AGO_RE, JUNK_PHRASE_RE, JUNK_URL_RE))


def clean_name_text(text: str, extra: list = None):
    """Изчиства отпадъци от име/заглавие. Връща (текст, променен_ли).

    Никога не връща празен резултат — ако след изчистването не остане нищо,
    връща оригинала, за да не остане файлът без име."""
    s = text or ""
    original = s
    s = s.replace("\u00a0", " ")
    try:
        s = html.unescape(s)                 # &amp; → &, &#039; → ' и т.н.
    except Exception:
        pass
    s = JUNK_URL_RE.sub(" ", s)
    for _ in range(6):                       # „53K views · 2K reactions · 3 days ago“
        t = JUNK_COUNT_RE.sub(" ", s)
        t = JUNK_AGO_RE.sub(" ", t)
        t = JUNK_PHRASE_RE.sub(" ", t)
        if t == s:
            break
        s = t
    for p in (extra or []):
        try:
            s = re.sub(re.escape(p), " ", s, flags=re.IGNORECASE)
        except re.error:
            continue
    s = _EMPTY_BRACKET_RE.sub(" ", s)        # останали празни ( ) [ ]
    s = _MULTI_SEP_RE.sub(" - ", s)          # „ - - “ → „ - “
    s = re.sub(r"\s{2,}", " ", s).strip()
    s = _EDGE_SEP_RE.sub("", s).strip()
    return (s, True) if (s and s != original) else (original, False)


def safe_filename_stem(s: str) -> str:
    """Прави името безопасно за файлова система: без < > : " / \\ | ? * и
    контролни знаци, без точки и интервали в края (изискване на Windows)."""
    s = _WIN_BAD_RE.sub(" ", s or "")
    return re.sub(r"\s{2,}", " ", s).strip().rstrip(". ")


def parse_patterns(raw: str) -> list:
    """Списък с потребителски текстове за премахване (разделени със запетая,
    точка и запетая или нов ред)."""
    out, seen = [], set()
    for part in re.split(r"[,;\n]", raw or ""):
        p = part.strip()
        if p and p.lower() not in seen and len(p) <= 120:
            seen.add(p.lower())
            out.append(p)
    return out[:20]


# ====================== ДВИГАТЕЛ ЗА НОРМАЛИЗАЦИЯ ======================

@dataclass
class FileResult:
    path: Path
    status: str                       # ok | skipped | failed | analyzed | cancelled
    input_i: float = None             # измерена сила (LUFS)
    input_tp: float = None            # измерен истински пик (dBTP)
    input_lra: float = None
    needed_gain: float = None         # нужната корекция спрямо целта (dB)
    message: str = ""
    src_kbps: float = None            # битрейт на оригинала (kbps)


class Normalizer:
    """Работен процес (стартира в отделна нишка). Общува с интерфейса
    ИЗКЛЮЧИТЕЛНО чрез emit(събитие, данни) — без пряк достъп до widgets."""

    def __init__(self, ffmpeg_path: str, cfg: dict, emit, cancel: threading.Event):
        self.ffmpeg = ffmpeg_path
        self.cfg = cfg
        self.emit = emit
        self.cancel = cancel
        self._cleaned = 0
        self._mutagen_hinted = False

    # ---------- главен цикъл ----------

    def run(self, files: list, root: Path) -> None:
        t0 = time.monotonic()
        counts = {"ok": 0, "skipped": 0, "failed": 0, "analyzed": 0, "cancelled": 0}
        results = []
        analyze = self.cfg["mode"] == "analyze"
        report = None
        try:
            tgt_kbps = int(str(self.cfg.get("bitrate", "192k")).rstrip("k"))
        except ValueError:
            tgt_kbps = None
        try:
            for idx, f in enumerate(files, 1):
                if self.cancel.is_set():
                    break
                rel = self.rel(f, root)
                self.emit("file_start", (idx, len(files), rel))
                res = self._handle_file(f, root, analyze)
                results.append(res)
                counts[res.status] = counts.get(res.status, 0) + 1
                self.emit("file_done", (idx, len(files), res, self.cfg["target_lufs"]))
                if (res.status == "ok" and res.src_kbps and tgt_kbps
                        and res.src_kbps > tgt_kbps + 8):
                    self.emit("log", (f"   ⚠ Битрейт: оригиналът е {res.src_kbps:.0f} kbps, "
                                      f"а целта е {tgt_kbps} kbps — прекодирането надолу "
                                      "губи качество.", "warn"))
                self.emit("total_progress", idx / len(files))
            if analyze and not self.cancel.is_set():
                report = self._write_report(root, results)
        except Exception as e:            # застраховка: интерфейсът никога не остава „зависнал“
            self.emit("log", (f"✗ Вътрешна грешка: {e}", "err"))
        self.emit("done", {
            "counts": counts,
            "elapsed": time.monotonic() - t0,
            "report": report,
            "cancelled": self.cancel.is_set(),
            "cleaned": self._cleaned,
        })

    def _handle_file(self, f: Path, root: Path, analyze: bool) -> FileResult:
        measured, info, err = self._measure(f)
        input_i = self._num(measured, "input_i")
        input_tp = self._num(measured, "input_tp")
        input_lra = self._num(measured, "input_lra")
        target = self.cfg["target_lufs"]

        if measured is None:
            return FileResult(f, "failed", input_i, input_tp, input_lra,
                              message=err or "неуспешно измерване")
        gain = None if input_i is None else target - input_i
        src_kbps = info.get("kbps")

        if analyze:
            return FileResult(f, "analyzed", input_i, input_tp, input_lra, gain,
                              src_kbps=src_kbps)

        if (self.cfg["skip_normalized"] and input_i is not None
                and abs(input_i - target) <= SKIP_TOLERANCE_LU
                and (input_tp is None or input_tp <= self.cfg["true_peak"] + TP_TOLERANCE_DB)):
            return self._postprocess(
                FileResult(f, "skipped", input_i, input_tp, input_lra, gain,
                           "без прекодиране", src_kbps=src_kbps))

        return self._postprocess(
            self._process(f, measured, input_i, input_tp, input_lra, root, info))

    def _process(self, f: Path, measured: dict, input_i, input_tp, input_lra,
                 root: Path, info: dict = None) -> FileResult:
        tmp = f.with_name(f"{f.stem}{TEMP_MARK}{uuid.uuid4().hex[:8]}{f.suffix}")
        try:
            status, msg, tchange = self._apply(f, tmp, measured, info)
            if status == "cancelled":
                return FileResult(f, "cancelled", input_i, input_tp, input_lra, message=msg)
            if status != "ok":
                return FileResult(f, "failed", input_i, input_tp, input_lra, message=msg)
            if self.cfg["backup"] and not self._backup(f, root):
                return FileResult(f, "failed", input_i, input_tp, input_lra,
                                  message="резервното копие не бе създадено — оригиналът е запазен непроменен")
            replaced, err = self._atomic_replace(tmp, f)
            if not replaced:
                return FileResult(f, "failed", input_i, input_tp, input_lra, message=err)
            if tchange:
                self._cleaned += 1
                self.emit("log", (f"   ✏ Заглавие в тага: „{tchange[0]}“ → „{tchange[1]}“", "info"))
            return FileResult(f, "ok", input_i, input_tp, input_lra, message=msg,
                              src_kbps=(info or {}).get("kbps"))
        finally:
            try:
                tmp.unlink(missing_ok=True)
            except OSError:
                pass

    # ---------- ffmpeg: измерване (проход 1) ----------

    def _measure(self, path: Path):
        i, tp, lra = self.cfg["target_lufs"], self.cfg["true_peak"], self.cfg["lra"]
        cmd = [self.ffmpeg, "-hide_banner", "-nostats", "-i", str(path),
               "-map", "0:a",
               "-af", f"loudnorm=I={i}:TP={tp}:LRA={lra}:print_format=json",
               "-f", "null", "-"]
        try:
            r = subprocess.run(cmd, capture_output=True, text=True,
                               encoding="utf-8", errors="replace", **sp_kwargs())
        except OSError as e:
            return None, {}, f"ffmpeg не може да бъде стартиран ({e})"
        stderr = r.stderr or ""
        info = self._info_from_banner(stderr)
        js, je = stderr.rfind("{"), stderr.rfind("}")
        if js != -1 and je > js:
            try:
                data = json.loads(stderr[js:je + 1])
                if "input_i" in data:
                    return data, info, None
            except json.JSONDecodeError:
                pass
        lines = [ln for ln in stderr.strip().splitlines() if ln.strip()]
        reason = lines[-1][:160] if lines else f"ffmpeg код {r.returncode}"
        return None, info, f"не може да се измери ({reason})"

    @staticmethod
    def _info_from_banner(stderr: str) -> dict:
        """Заглавие, честота и битрейт на входа — прочетени от банера на
        ffmpeg при измерването, без допълнителен процес и без библиотеки."""
        info = {}
        try:
            inp = stderr.split("Output #", 1)[0]        # само входният блок
            m = re.search(r"Audio:.*?,\s*(\d+)\s*Hz", inp)
            if m:
                info["rate"] = int(m.group(1))
            m = (re.search(r"Audio:.*?,\s*(\d+)\s*kb/s", inp)
                 or re.search(r"bitrate:\s*(\d+)\s*kb/s", inp))
            if m:
                info["kbps"] = int(m.group(1))
            head = inp.split("Stream #", 1)[0]          # метаданните са преди потоците
            if "\ufffd" not in head:                    # развалено декодиране → не рискуваме
                m = re.search(r"^\s*title\s+:\s*(.+?)\s*$", head,
                              re.MULTILINE | re.IGNORECASE)
                if m:
                    info["title"] = m.group(1).strip()
        except Exception:
            pass
        return info

    # ---------- ffmpeg: прилагане (проход 2) ----------

    def _apply(self, src: Path, dst: Path, measured: dict, info: dict = None):
        i, tp, lra = self.cfg["target_lufs"], self.cfg["true_peak"], self.cfg["lra"]
        mi = self._num(measured, "input_i")
        mtp = self._num(measured, "input_tp")
        mlra = self._num(measured, "input_lra")
        mth = self._num(measured, "input_thresh")
        off = self._num(measured, "target_offset")

        if None not in (mi, mtp, mth):
            af = (f"loudnorm=I={i}:TP={tp}:LRA={lra}"
                  f":measured_I={mi}:measured_TP={mtp}"
                  f":measured_LRA={mlra if mlra is not None else lra}"
                  f":measured_thresh={mth}:offset={off if off is not None else 0.0}"
                  f":linear=true:print_format=summary")
            note = "two-pass linear"
        else:
            # безшумни/повредени данни → сигурен динамичен режим в един проход
            af = f"loudnorm=I={i}:TP={tp}:LRA={lra}"
            note = "динамичен режим (без валидни измервания)"

        info = info or {}
        rate = choose_sample_rate(info.get("rate"))   # оригиналната честота, ако е валидна
        cmd = [self.ffmpeg, "-hide_banner", "-nostats", "-loglevel", "error", "-y",
               "-i", str(src), "-af", af,
               "-ar", str(rate), "-b:a", self.cfg["bitrate"], "-id3v2_version", "3",
               # корицата се пренася бит-в-бит — без това ffmpeg тихо я прекодира в PNG
               "-c:v", "copy"]
        # ВАЖНО: -metadata трябва да е ПРЕДИ изходния файл, иначе ffmpeg го игнорира
        tchange = None
        title = info.get("title", "")
        if self.cfg.get("clean_title_tag") and title:
            new_title, changed = clean_name_text(title, self.cfg.get("clean_patterns"))
            if changed and new_title:
                cmd += ["-metadata", f"title={new_title}"]
                tchange = (title, new_title)
        cmd.append(str(dst))
        try:
            with tempfile.TemporaryFile(mode="w+", encoding="utf-8", errors="replace") as errf:
                proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=errf, **sp_kwargs())
                while True:
                    rc = proc.poll()
                    if rc is not None:
                        break
                    if self.cancel.is_set():
                        self._terminate(proc)
                        return "cancelled", "спряно от потребителя", None
                    time.sleep(0.15)
                errf.seek(0)
                err = errf.read()
        except OSError as e:
            return "failed", f"ffmpeg грешка: {e}", None
        if self.cancel.is_set():
            return "cancelled", "спряно от потребителя", None
        if rc != 0:
            lines = [ln for ln in (err or "").strip().splitlines() if ln.strip()]
            return "failed", (lines[-1][:200] if lines else f"ffmpeg код {rc}"), None
        return "ok", note, tchange

    # ---------- помощни операции ----------

    def _backup(self, original: Path, root: Path) -> bool:
        try:
            dest = root / BACKUP_DIR_NAME / original.relative_to(root)
            dest.parent.mkdir(parents=True, exist_ok=True)
            if not dest.exists():
                shutil.copy2(original, dest)
            return dest.exists()
        except OSError:
            return False

    # ---------- почистване на име/заглавие ----------

    def _postprocess(self, res: FileResult) -> FileResult:
        """След успешна обработка или пропускане — изчистване на името на
        файла и (при пропуснатите) на заглавието в тага."""
        if res.status not in ("ok", "skipped"):
            return res
        if self.cfg.get("clean_names"):
            self._rename_clean(res)
        if res.status == "skipped" and self.cfg.get("clean_title_tag"):
            self._fix_tag_title(res.path)
        return res

    def _rename_clean(self, res: FileResult) -> None:
        f = res.path
        new_stem, changed = clean_name_text(f.stem, self.cfg.get("clean_patterns"))
        if not changed:
            if has_junk(f.stem):
                self.emit("log", ("   ⚠ След изчистване няма да остане валидно име — "
                                  "не преименувам", "warn"))
            return
        new_stem = safe_filename_stem(new_stem)
        if not new_stem:
            return
        target = self._unique_path(f.with_name(new_stem + f.suffix))
        if target == f:
            return
        ok, err = self._rename_with_retry(f, target)
        if ok:
            self._cleaned += 1
            self.emit("log", (f"   ✏ Име: „{f.name}“ → „{target.name}“", "info"))
            res.path = target
        else:
            self.emit("log", (f"   ⚠ Името не можа да се смени ({err})", "warn"))

    def _fix_tag_title(self, f: Path) -> None:
        """Изчиства заглавието (TIT2) в тага на пропуснат файл — променят се
        само метаданните, аудио данните не се пипат. Изисква mutagen."""
        try:
            from mutagen.id3 import ID3, TIT2   # незадължителна зависимост
        except ImportError:
            self._hint_mutagen()
            return
        try:
            tags = ID3(str(f))
        except Exception:
            return
        frames = tags.getall("TIT2")
        if not frames:
            return
        old = str(frames[0])
        new, changed = clean_name_text(old, self.cfg.get("clean_patterns"))
        if not changed or not new:
            return
        try:
            tags.setall("TIT2", [TIT2(encoding=1, text=[new])])
            tags.update_to_v23()
            tags.save(str(f), v2_version=3)
        except Exception as e:
            self.emit("log", (f"   ⚠ Заглавието в тага не можа да се обнови ({e})", "warn"))
            return
        self._cleaned += 1
        self.emit("log", (f"   ✏ Заглавие в тага: „{old}“ → „{new}“", "info"))

    def _hint_mutagen(self) -> None:
        if not self._mutagen_hinted:
            self._mutagen_hinted = True
            self.emit("log", ("   ⚠ За почистване на заглавието в тага и при "
                              "пропуснатите файлове инсталирай: pip install mutagen", "warn"))

    @staticmethod
    def _unique_path(p: Path) -> Path:
        if not p.exists():
            return p
        for i in range(2, 100):
            q = p.with_name(f"{p.stem} ({i}){p.suffix}")
            if not q.exists():
                return q
        return p

    @staticmethod
    def _rename_with_retry(f: Path, target: Path):
        last = ""
        for _ in range(REPLACE_RETRIES):
            try:
                if target.exists():              # застраховка срещу презапис
                    return False, "вече съществува файл с това име"
                f.rename(target)
                return True, ""
            except PermissionError:
                last = "файлът е зает (възпроизвежда ли се в момента?)"
                time.sleep(0.8)
            except OSError as e:
                return False, str(e)
        return False, last

    @staticmethod
    def _atomic_replace(src: Path, dst: Path):
        last = ""
        for _ in range(REPLACE_RETRIES):
            try:
                os.replace(src, dst)
                return True, ""
            except PermissionError:
                last = "файлът е зает (възпроизвежда ли се в момента?)"
                time.sleep(0.8)
            except OSError as e:
                last = str(e)
                break
        return False, f"замяната не успя — {last}"

    @staticmethod
    def _terminate(proc) -> None:
        try:
            proc.terminate()
            proc.wait(timeout=5)
        except Exception:
            try:
                proc.kill()
            except Exception:
                pass

    @staticmethod
    def rel(p: Path, root: Path) -> str:
        try:
            return str(p.relative_to(root))
        except ValueError:
            return p.name

    @staticmethod
    def _num(d, key: str):
        if not d:
            return None
        try:
            v = float(str(d.get(key, "")).strip())
        except (TypeError, ValueError):
            return None
        return v if math.isfinite(v) else None

    def _write_report(self, root: Path, results: list):
        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
        path = root / f"loudness_report_{ts}.csv"
        try:
            with open(path, "w", newline="", encoding="utf-8-sig") as fh:
                w = csv.writer(fh, delimiter=";")
                w.writerow(["Файл", "Сила (LUFS)", "Пик TP (dBTP)", "LRA",
                            "Цел (LUFS)", "Нужна корекция (dB)", "Източник (kbps)",
                            "Предложено име"])
                for r in results:
                    stem, changed = clean_name_text(r.path.stem,
                                                    self.cfg.get("clean_patterns"))
                    w.writerow([self.rel(r.path, root),
                                fmt_num(r.input_i, 2), fmt_num(r.input_tp, 2),
                                fmt_num(r.input_lra, 2), self.cfg["target_lufs"],
                                fmt_num(r.needed_gain, 2), fmt_num(r.src_kbps, 0),
                                f"{stem}{r.path.suffix}" if changed and stem else ""])
            return path
        except OSError:
            return None


# ====================== ТЪРСЕНЕ НА FFMPEG ======================

def locate_ffmpeg(custom: str = ""):
    """Връща (път до ffmpeg | None, версия). Проверява ръчно зададен път,
    PATH и типичните места за инсталация под Windows."""
    candidates = []
    if custom:
        candidates.append(custom)
    w = shutil.which("ffmpeg")
    if w:
        candidates.append(w)
    if IS_WINDOWS:
        pf = os.environ.get("ProgramFiles", r"C:\Program Files")
        pf86 = os.environ.get("ProgramFiles(x86)", pf)
        la = os.environ.get("LOCALAPPDATA", "")
        here = str(Path(__file__).resolve().parent)
        candidates += [
            r"C:\ffmpeg\bin\ffmpeg.exe",
            r"C:\ffmpeg\ffmpeg.exe",
            os.path.join(pf, "ffmpeg", "bin", "ffmpeg.exe"),
            os.path.join(pf86, "ffmpeg", "bin", "ffmpeg.exe"),
            os.path.join(la, "Microsoft", "WinGet", "Links", "ffmpeg.exe"),
            os.path.join(la, "Programs", "ffmpeg", "bin", "ffmpeg.exe"),
            os.path.join(here, "ffmpeg.exe"),
            os.path.join(here, "ffmpeg", "bin", "ffmpeg.exe"),
        ]
    seen = set()
    for c in candidates:
        if not c or c in seen:
            continue
        seen.add(c)
        if os.path.isfile(c) and _ffmpeg_ok(c):
            return c, _ffmpeg_version(c)
    return None, ""


def _ffmpeg_ok(path: str) -> bool:
    try:
        r = subprocess.run([path, "-version"], capture_output=True, text=True,
                           encoding="utf-8", errors="replace", timeout=15, **sp_kwargs())
        return r.returncode == 0 and "ffmpeg version" in (r.stdout or "")
    except (OSError, subprocess.TimeoutExpired):
        return False


def _ffmpeg_version(path: str) -> str:
    try:
        r = subprocess.run([path, "-version"], capture_output=True, text=True,
                           encoding="utf-8", errors="replace", timeout=15, **sp_kwargs())
        lines = (r.stdout or "").splitlines()
        if lines:
            return lines[0].replace("ffmpeg version ", "").strip() or "unknown"
    except Exception:
        pass
    return "unknown"


# ====================== ГРАФИЧЕН ИНТЕРФЕЙС ======================

class App(ctk.CTk):
    def __init__(self, settings: dict):
        super().__init__()
        self.settings = settings
        self.ffmpeg_path = None
        self._running = False
        self.events = queue.Queue()
        self.cancel_event = threading.Event()
        self.worker = None
        self._t0 = 0.0

        self.title(APP_NAME)
        self.folder_var = ctk.StringVar(value=str(settings.get("last_folder") or ""))
        self._build()
        self._init_geometry()
        self._bind_log_tags()
        self.protocol("WM_DELETE_WINDOW", self._on_close)

        # докато търсим ffmpeg — контролите са заключени
        self.main_btn.configure(state="disabled", text="Проверка за ffmpeg…")
        self._lock_options(True)
        self.after(80, self._pump)
        self._detect_ffmpeg_async()

    # ---------- изграждане на интерфейса ----------

    def _build(self):
        PAD = 24
        head = ctk.CTkFrame(self, fg_color="transparent")
        head.pack(fill="x", padx=PAD, pady=(16, 0))
        ctk.CTkLabel(head, text="MP3 Balance",
                     font=ctk.CTkFont(size=26, weight="bold")).pack(side="left")
        ctk.CTkLabel(head, text=f"v{APP_VERSION}",
                     font=ctk.CTkFont(size=12), text_color="gray60").pack(side="right")
        ctk.CTkLabel(self, text="Нормализиране на силата на звука с ffmpeg (двупроходен loudnorm, EBU R128)",
                     font=ctk.CTkFont(size=13), text_color="gray70").pack(pady=(0, 12))

        # ---- избор на папка ----
        ff = ctk.CTkFrame(self)
        ff.pack(fill="x", padx=PAD, pady=6)
        ctk.CTkLabel(ff, text="Папка с MP3 файлове",
                     font=ctk.CTkFont(size=13, weight="bold")).pack(anchor="w", padx=14, pady=(10, 2))
        row = ctk.CTkFrame(ff, fg_color="transparent")
        row.pack(fill="x", padx=14, pady=(2, 12))
        self.path_entry = ctk.CTkEntry(row, textvariable=self.folder_var,
                                       placeholder_text="Избери папка...", height=36)
        self.path_entry.pack(side="left", fill="x", expand=True, padx=(0, 8))
        self.browse_btn = ctk.CTkButton(row, text="Избери...", width=100, height=36,
                                        command=self._browse_folder)
        self.browse_btn.pack(side="left", padx=(0, 8))
        self.open_btn = ctk.CTkButton(row, text="Отвори", width=90, height=36,
                                      fg_color="gray40", hover_color="gray25",
                                      command=self._open_folder)
        self.open_btn.pack(side="left")

        # ---- опции ----
        opt = ctk.CTkFrame(self)
        opt.pack(fill="x", padx=PAD, pady=6)
        opt.columnconfigure(1, weight=1)

        ctk.CTkLabel(opt, text="Пресет", font=ctk.CTkFont(size=12)).grid(
            row=0, column=0, sticky="w", padx=(14, 8), pady=(12, 4))
        self.preset_combo = ctk.CTkComboBox(opt, values=list(PRESETS.keys()),
                                            state="readonly", height=32,
                                            command=self._on_preset_change)
        self.preset_combo.grid(row=0, column=1, columnspan=2, sticky="we", padx=(0, 14), pady=(12, 4))
        self.preset_combo.set(self._match_preset())

        ctk.CTkLabel(opt, text="Битрейт", font=ctk.CTkFont(size=12)).grid(
            row=1, column=0, sticky="w", padx=(14, 8), pady=4)
        self.bitrate_combo = ctk.CTkComboBox(opt, values=list(BITRATES.keys()),
                                             state="readonly", width=220, height=32)
        self.bitrate_combo.grid(row=1, column=1, sticky="w", padx=(0, 14), pady=4)
        for label, val in BITRATES.items():
            if val == self.settings["bitrate"]:
                self.bitrate_combo.set(label)
                break
        else:
            self.bitrate_combo.set("192 kbps (препоръчително)")

        self.mode_seg = ctk.CTkSegmentedButton(
            opt, values=[MODE_NORMALIZE, MODE_ANALYZE],
            command=self._on_mode_change, font=ctk.CTkFont(size=13))
        self.mode_seg.grid(row=1, column=2, sticky="e", padx=(0, 14), pady=4)
        self.mode_seg.set(MODE_NORMALIZE)

        checks = ctk.CTkFrame(opt, fg_color="transparent")
        checks.grid(row=2, column=0, columnspan=3, sticky="we", padx=8, pady=(6, 2))
        self.recursive_var = ctk.BooleanVar(value=bool(self.settings["recursive"]))
        self.backup_var = ctk.BooleanVar(value=bool(self.settings["backup"]))
        self.skip_var = ctk.BooleanVar(value=bool(self.settings["skip_normalized"]))
        self.recursive_check = ctk.CTkCheckBox(checks, text="Включи подпапките",
                                               variable=self.recursive_var)
        self.recursive_check.pack(side="left", padx=6, pady=6)
        self.backup_check = ctk.CTkCheckBox(checks, text="Резервно копие в „_originals“",
                                            variable=self.backup_var)
        self.backup_check.pack(side="left", padx=6, pady=6)
        self.skip_check = ctk.CTkCheckBox(
            checks, text=f"Пропусни вече нормализирани (±{SKIP_TOLERANCE_LU:g} LU)",
            variable=self.skip_var)
        self.skip_check.pack(side="left", padx=6, pady=6)

        # ---- почистване на имена от социални отпадъци ----
        self.clean_names_var = ctk.BooleanVar(value=bool(self.settings["clean_names"]))
        self.clean_tag_var = ctk.BooleanVar(value=bool(self.settings["clean_title_tag"]))
        checks2 = ctk.CTkFrame(opt, fg_color="transparent")
        checks2.grid(row=3, column=0, columnspan=3, sticky="we", padx=8, pady=(0, 2))
        self.clean_names_check = ctk.CTkCheckBox(
            checks2, text="Почисти имена от „53K views · 2K reactions“ и подобни",
            variable=self.clean_names_var, command=self._sync_option_states)
        self.clean_names_check.pack(side="left", padx=6, pady=4)
        self.clean_tag_check = ctk.CTkCheckBox(
            checks2, text="…и заглавието (Title) в тага",
            variable=self.clean_tag_var)
        self.clean_tag_check.pack(side="left", padx=6, pady=4)
        prow = ctk.CTkFrame(checks2, fg_color="transparent")
        prow.pack(fill="x", padx=6, pady=(0, 6))
        ctk.CTkLabel(prow, text="Допълнителни текстове за премахване:",
                     font=ctk.CTkFont(size=12), text_color="gray70").pack(side="left", padx=(0, 8))
        self.clean_patterns_entry = ctk.CTkEntry(
            prow, height=30,
            placeholder_text="напр. Full video, име на страница — разделени със запетая")
        self.clean_patterns_entry.pack(side="left", fill="x", expand=True)
        if self.settings.get("clean_patterns"):
            self.clean_patterns_entry.insert(0, str(self.settings["clean_patterns"]))

        # персонализирани параметри (видими само при „Персонализирано...“)
        self.custom_frame = ctk.CTkFrame(opt, fg_color="transparent")
        self.custom_frame.grid(row=4, column=0, columnspan=3, sticky="we", padx=8, pady=(0, 6))
        self.custom_frame.grid_remove()
        self.custom_vars = {}
        col = 0
        for lbl, key in (("Цел (LUFS)", "target_lufs"),
                         ("True Peak (dBTP)", "true_peak"),
                         ("LRA", "lra")):
            ctk.CTkLabel(self.custom_frame, text=lbl,
                         font=ctk.CTkFont(size=12)).grid(row=0, column=col, padx=(10, 4), pady=4, sticky="e")
            var = ctk.StringVar(value=f"{float(self.settings[key]):g}")
            self.custom_vars[key] = var
            ctk.CTkEntry(self.custom_frame, textvariable=var, width=76,
                         justify="center").grid(row=0, column=col + 1, padx=(0, 10), pady=4)
            col += 2

        self.info_label = ctk.CTkLabel(opt, text="", font=ctk.CTkFont(size=12), text_color="gray60")
        self.info_label.grid(row=5, column=0, columnspan=3, sticky="e", padx=14, pady=(0, 10))
        self._on_preset_change(self.preset_combo.get())

        # ---- главен бутон ----
        self.main_btn = ctk.CTkButton(self, text="Стартирай обработката", height=46,
                                      font=ctk.CTkFont(size=16, weight="bold"),
                                      command=self._on_main_button,
                                      fg_color="#1f6aa5", hover_color="#144870")
        self.main_btn.pack(fill="x", padx=PAD, pady=10)

        # ---- прогрес ----
        prog = ctk.CTkFrame(self)
        prog.pack(fill="x", padx=PAD, pady=6)
        self.progress_label = ctk.CTkLabel(prog, text="Готов за работа",
                                           font=ctk.CTkFont(size=13), anchor="w")
        self.progress_label.pack(fill="x", padx=14, pady=(10, 4))
        self.progress_bar = ctk.CTkProgressBar(prog, height=16)
        self.progress_bar.pack(fill="x", padx=14, pady=(0, 4))
        self.progress_bar.set(0)
        self.pct_label = ctk.CTkLabel(prog, text="", font=ctk.CTkFont(size=12),
                                      text_color="gray60", anchor="w")
        self.pct_label.pack(fill="x", padx=14, pady=(0, 10))

        # ---- лог ----
        logf = ctk.CTkFrame(self)
        logf.pack(fill="both", expand=True, padx=PAD, pady=(6, 8))
        lrow = ctk.CTkFrame(logf, fg_color="transparent")
        lrow.pack(fill="x", padx=12, pady=(8, 2))
        ctk.CTkLabel(lrow, text="Лог", font=ctk.CTkFont(size=13, weight="bold")).pack(side="left")
        ctk.CTkButton(lrow, text="Изчисти", width=84, height=28,
                      font=ctk.CTkFont(size=12), fg_color="gray40", hover_color="gray25",
                      command=self._clear_log).pack(side="right", padx=(6, 0))
        ctk.CTkButton(lrow, text="Запиши лога...", width=130, height=28,
                      font=ctk.CTkFont(size=12), fg_color="gray40", hover_color="gray25",
                      command=self._export_log).pack(side="right")
        self.log_text = ctk.CTkTextbox(logf, font=ctk.CTkFont(family="Consolas", size=12),
                                       wrap="word")
        self.log_text.pack(fill="both", expand=True, padx=12, pady=(2, 12))

        # ---- статус лента ----
        status = ctk.CTkFrame(self, height=30, fg_color=("gray86", "gray17"))
        status.pack(fill="x", side="bottom")
        self.ffmpeg_status = ctk.CTkLabel(status, text="● Проверка за ffmpeg…",
                                          font=ctk.CTkFont(size=12), text_color="gray60")
        self.ffmpeg_status.pack(side="left", padx=14, pady=4)
        try:
            self.ffmpeg_status.configure(cursor="hand2")
        except Exception:
            pass
        self.ffmpeg_status.bind("<Button-1>", self._choose_ffmpeg)
        ctk.CTkLabel(status, text=f"Настройки: {SETTINGS_PATH.name}",
                     font=ctk.CTkFont(size=11), text_color="gray55").pack(side="right", padx=14, pady=4)

    def _init_geometry(self):
        self.minsize(840, 660)
        saved = str(self.settings.get("geometry") or "")
        if re.fullmatch(r"\d+x\d+[-+]\d+[-+]\d+", saved):
            self.geometry(saved)
        else:
            w, h = 900, 760
            sw, sh = self.winfo_screenwidth(), self.winfo_screenheight()
            self.geometry(f"{w}x{h}+{max(0, (sw - w) // 2)}+{max(0, (sh - h) // 2 - 20)}")

    # ---------- лог ----------

    def _bind_log_tags(self):
        for tag, color in (("ok", "#6fce6f"), ("err", "#f27070"), ("warn", "#eebb66"),
                           ("info", "#8fc7ff"), ("dim", "gray58"), ("skip", "#d9c06b")):
            try:
                self.log_text.tag_config(tag, foreground=color)
            except Exception:
                try:
                    self.log_text._textbox.tag_config(tag, foreground=color)
                except Exception:
                    pass

    def _append_log(self, msg: str, tag: str = ""):
        start = None
        try:
            start = self.log_text.index("end-1c")
        except Exception:
            try:
                start = self.log_text._textbox.index("end-1c")
            except Exception:
                start = None
        self.log_text.insert("end", msg + "\n")
        if tag and start:
            try:
                self.log_text.tag_add(tag, start, "end-1c")
            except Exception:
                try:
                    self.log_text._textbox.tag_add(tag, start, "end-1c")
                except Exception:
                    pass
        self.log_text.see("end")

    def log(self, msg: str, tag: str = ""):
        """Нишково-безопасен лог (работи и от работната нишка)."""
        self.events.put(("log", (msg, tag)))

    def _clear_log(self):
        self.log_text.delete("1.0", "end")

    def _export_log(self):
        content = self.log_text.get("1.0", "end").rstrip()
        if not content.strip():
            messagebox.showinfo(APP_NAME, "Логът е празен — няма какво да се запише.")
            return
        initial = f"loudnorm_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
        base = self._clean_folder()
        path = filedialog.asksaveasfilename(
            title="Запиши лога като...",
            initialdir=base if base and Path(base).is_dir() else str(Path.home()),
            initialfile=initial, defaultextension=".txt",
            filetypes=[("Текстов файл", "*.txt"), ("Всички файлове", "*.*")])
        if not path:
            return
        try:
            Path(path).write_text(content, encoding="utf-8")
            self.log(f"Логът е записан в: {path}", "ok")
        except OSError as e:
            messagebox.showerror(APP_NAME, f"Логът не може да бъде записан:\n{e}")

    # ---------- събития от работната нишка ----------

    def _pump(self):
        try:
            while True:
                name, payload = self.events.get_nowait()
                try:
                    self._dispatch(name, payload)
                except Exception:
                    pass
        except queue.Empty:
            pass
        self.after(80, self._pump)

    def _dispatch(self, name, payload):
        if name == "log":
            self._append_log(*payload)
        elif name == "file_start":
            idx, total, rel = payload
            self.progress_label.configure(text=f"Измерване: {rel}   ({idx}/{total})")
            self.log(f"[{idx}/{total}] {rel}", "dim")
            self._set_progress((idx - 1) / max(1, total))
        elif name == "file_done":
            self._on_file_done(*payload)
        elif name == "total_progress":
            self._set_progress(payload)
        elif name == "done":
            self._finish_ui(payload)
        elif name == "ffmpeg":
            self._on_ffmpeg_found(payload)

    def _on_file_done(self, idx, total, res, target):
        if res.status == "ok":
            self.log(f"   ✓ нормализиран: {fmt_num(res.input_i)} → {target:g} LUFS  ({res.message})", "ok")
        elif res.status == "skipped":
            self.log(f"   • вече в норма ({fmt_num(res.input_i)} LUFS) — пропуснат без прекодиране", "skip")
        elif res.status == "analyzed":
            if res.needed_gain is None:
                self.log("   → не се измерва коректно (безшумен или повреден запис?)", "warn")
            else:
                self.log(f"   → {fmt_num(res.input_i)} LUFS · TP {fmt_num(res.input_tp)} dBTP"
                         f" · LRA {fmt_num(res.input_lra)} · корекция {res.needed_gain:+.1f} dB", "info")
        elif res.status == "failed":
            self.log(f"   ✗ {res.message}", "err")

    def _finish_ui(self, payload):
        c = payload["counts"]
        total = sum(c.values())
        self.log("", "")
        self.log("──────────────── ИТОГ ────────────────", "info")
        self.log(f"   Файлове: {total}", "")
        if c.get("ok"):
            self.log(f"   ✓ Нормализирани: {c['ok']}", "ok")
        if c.get("skipped"):
            self.log(f"   • Пропуснати (вече в норма): {c['skipped']}", "skip")
        if c.get("analyzed"):
            self.log(f"   → Анализирани: {c['analyzed']}", "info")
        if payload.get("cleaned"):
            self.log(f"   ✏ Изчистени имена/заглавия: {payload['cleaned']}", "info")
        if c.get("failed"):
            self.log(f"   ✗ Грешки: {c['failed']}", "err")
        if payload.get("cancelled"):
            self.log("   ⚠ Спряно от потребителя — текущият файл остава непроменен.", "warn")
        if payload.get("report"):
            self.log(f"   CSV отчет: {payload['report']}", "info")
        self.log(f"   Време: {fmt_sec(payload['elapsed'])}", "dim")
        self.progress_label.configure(
            text=f"Завършено: {c.get('ok', 0)} успешни, {c.get('skipped', 0)} пропуснати, "
                 f"{c.get('failed', 0)} грешки" + (" (спряно)" if payload["cancelled"] else ""))
        if not payload["cancelled"]:
            self._set_progress(1.0)
        self._set_running(False)

    def _set_progress(self, frac: float):
        frac = max(0.0, min(1.0, frac))
        self.progress_bar.set(frac)
        self.pct_label.configure(text=f"{frac * 100:.0f}%" if self._running else "")

    # ---------- старт / стоп ----------

    def _on_main_button(self):
        if self._running:
            self._stop()
        else:
            self._start()

    def _start(self):
        if self._running:
            return
        folder = self._clean_folder()
        if not folder:
            messagebox.showwarning(APP_NAME, "Първо избери папка с MP3 файлове.")
            return
        root = Path(folder)
        if not root.is_dir():
            messagebox.showwarning(APP_NAME, "Посочената папка не съществува:\n" + folder)
            return
        params = self._params_now()
        if params is None:
            messagebox.showwarning(
                APP_NAME, "Провери персонализираните параметри — извън валидните граници:\n"
                          "Цел (LUFS): от −70 до −5\n"
                          "True Peak (dBTP): от −9 до 0\n"
                          "LRA: от 1 до 50")
            return
        if not self.ffmpeg_path:
            self._prompt_ffmpeg_missing()
            return

        files = scan_mp3(root, self.recursive_var.get())
        if not files:
            hint = "" if self.recursive_var.get() else \
                "\n\nПодсказка: включи „Включи подпапките“, ако файловете са в тях."
            messagebox.showinfo(APP_NAME, "В избраната папка няма MP3 файлове." + hint)
            return

        analyze = self.mode_seg.get() == MODE_ANALYZE
        patterns_raw = self.clean_patterns_entry.get().strip()
        cfg = {
            "target_lufs": params[0], "true_peak": params[1], "lra": params[2],
            "bitrate": BITRATES.get(self.bitrate_combo.get(), "192k"),
            "recursive": self.recursive_var.get(),
            "backup": self.backup_var.get() and not analyze,
            "skip_normalized": self.skip_var.get() and not analyze,
            "clean_names": self.clean_names_var.get() and not analyze,
            "clean_title_tag": (self.clean_tag_var.get() and self.clean_names_var.get()
                                and not analyze),
            "clean_patterns": parse_patterns(patterns_raw),
            "mode": "analyze" if analyze else "normalize",
        }
        self.settings.update({
            "target_lufs": params[0], "true_peak": params[1], "lra": params[2],
            "bitrate": cfg["bitrate"], "recursive": cfg["recursive"],
            "backup": bool(self.backup_var.get()),
            "skip_normalized": bool(self.skip_var.get()),
            "clean_names": bool(self.clean_names_var.get()),
            "clean_title_tag": bool(self.clean_tag_var.get()),
            "clean_patterns": patterns_raw,
            "last_folder": folder,
        })
        save_settings({**self.settings, "geometry": self.geometry()})

        self.log_text.delete("1.0", "end")
        mode_text = MODE_ANALYZE if analyze else MODE_NORMALIZE
        self.log(f"─ Режим: {mode_text} · Цел: I={params[0]:g} LUFS · "
                 f"TP={params[1]:g} dBTP · LRA={params[2]:g}", "info")
        if not analyze:
            self.log(f"─ Битрейт: {cfg['bitrate']} · Backup: {'вкл.' if cfg['backup'] else 'изкл.'}"
                     f" · Прескачане на нормализирани: {'вкл.' if cfg['skip_normalized'] else 'изкл.'}", "dim")
            if cfg["clean_names"]:
                extra = (f" · допълнителни текстове: {', '.join(cfg['clean_patterns'])}"
                         if cfg["clean_patterns"] else "")
                self.log(f"─ Почистване на имена: вкл. · Заглавие в тага: "
                         f"{'вкл.' if cfg['clean_title_tag'] else 'изкл.'}{extra}", "dim")
        self.log(f"─ Папка: {folder} ({'с подпапки' if cfg['recursive'] else 'само горната папка'})"
                 f" · Файлове: {len(files)}", "dim")

        self._set_running(True)
        self._set_progress(0.0)
        self.cancel_event = threading.Event()
        engine = Normalizer(self.ffmpeg_path, cfg,
                            lambda name, payload: self.events.put((name, payload)),
                            self.cancel_event)
        self.worker = threading.Thread(target=engine.run, args=(files, root),
                                       daemon=True, name="NormalizerWorker")
        self.worker.start()

    def _stop(self):
        if not self._running:
            return
        self.cancel_event.set()
        self.main_btn.configure(state="disabled", text="Спиране…")
        self.log("⚠ Спиране — прекъствам текущата ffmpeg операция…", "warn")

    def _set_running(self, running: bool):
        self._running = running
        if running:
            self._t0 = time.monotonic()
            self.main_btn.configure(text="Спри", fg_color="#a51f1f", hover_color="#701414",
                                    state="normal")
            self._lock_options(True)
        else:
            self.main_btn.configure(text="Стартирай обработката", fg_color="#1f6aa5",
                                    hover_color="#144870", state="normal")
            self._lock_options(False)

    # ---------- състояние на контролите ----------

    def _lock_options(self, lock: bool):
        st = "disabled" if lock else "normal"
        for w in (self.recursive_check, self.backup_check, self.skip_check,
                  self.clean_names_check, self.clean_tag_check,
                  self.clean_patterns_entry, self.browse_btn, self.open_btn,
                  self.mode_seg, self.path_entry):
            w.configure(state=st)
        for c in (self.preset_combo, self.bitrate_combo):
            c.configure(state="disabled" if lock else "readonly")
        if not lock:
            self._sync_option_states()

    def _sync_option_states(self):
        """В режим „Само анализ“ част от контролите са без значение."""
        analyze = self.mode_seg.get() == MODE_ANALYZE
        self.bitrate_combo.configure(state="disabled" if analyze else "readonly")
        st = "disabled" if analyze else "normal"
        self.backup_check.configure(state=st)
        self.skip_check.configure(state=st)
        self.clean_names_check.configure(state=st)
        self.clean_tag_check.configure(
            state="normal" if (not analyze and self.clean_names_var.get()) else "disabled")

    def _on_mode_change(self, _value=None):
        self._sync_option_states()

    # ---------- параметри / пресети ----------

    def _match_preset(self) -> str:
        target = (self.settings.get("target_lufs"), self.settings.get("true_peak"),
                  self.settings.get("lra"))
        for name, params in PRESETS.items():
            if params and tuple(params) == tuple(target):
                return name
        return CUSTOM_LABEL

    def _on_preset_change(self, value: str = None):
        if value == CUSTOM_LABEL:
            self.custom_frame.grid()
        else:
            self.custom_frame.grid_remove()
        self._update_info_label()

    def _custom_params(self):
        try:
            i = float(self.custom_vars["target_lufs"].get().replace(",", "."))
            tp = float(self.custom_vars["true_peak"].get().replace(",", "."))
            lra = float(self.custom_vars["lra"].get().replace(",", "."))
        except (KeyError, ValueError):
            return None
        if not valid_custom_params(i, tp, lra):
            return None
        return i, tp, lra

    def _params_now(self):
        label = self.preset_combo.get()
        if label != CUSTOM_LABEL:
            return PRESETS.get(label)
        return self._custom_params()

    def _update_info_label(self):
        p = self._params_now()
        if p:
            self.info_label.configure(
                text=f"Цел: I={p[0]:g} LUFS · TP={p[1]:g} dBTP · LRA={p[2]:g}",
                text_color="gray60")
        else:
            self.info_label.configure(
                text="Персонализираните параметри са непълни или невалидни",
                text_color="#f27070")

    # ---------- папки ----------

    def _clean_folder(self) -> str:
        return self.folder_var.get().strip().strip('"').strip("'").strip()

    def _browse_folder(self):
        base = self._clean_folder()
        d = filedialog.askdirectory(
            title="Избери папка с MP3 файлове",
            initialdir=base if base and Path(base).is_dir() else str(Path.home()))
        if d:
            self.folder_var.set(d)

    def _open_folder(self):
        d = self._clean_folder()
        if d and Path(d).is_dir():
            try:
                if IS_WINDOWS:
                    os.startfile(d)                     # noqa: само Windows
                elif sys.platform == "darwin":
                    subprocess.Popen(["open", d], **sp_kwargs())
                else:
                    subprocess.Popen(["xdg-open", d])
            except OSError as e:
                messagebox.showerror(APP_NAME, f"Папката не може да бъде отворена:\n{e}")
        else:
            messagebox.showinfo(APP_NAME, "Няма избрана валидна папка.")

    # ---------- ffmpeg ----------

    def _detect_ffmpeg_async(self):
        custom = str(self.settings.get("ffmpeg_path") or "")

        def job():
            path, ver = locate_ffmpeg(custom)
            self.events.put(("ffmpeg", (path, ver)))

        threading.Thread(target=job, daemon=True, name="FfmpegDetect").start()

    def _on_ffmpeg_found(self, payload):
        path, ver = payload
        self.ffmpeg_path = path
        self._lock_options(False)
        if path:
            self.settings["ffmpeg_path"] = path
            self.ffmpeg_status.configure(text=f"● ffmpeg {ver}", text_color="#6fce6f")
            self.log(f"ffmpeg намерен: {path}", "dim")
        else:
            self.settings["ffmpeg_path"] = ""
            self.ffmpeg_status.configure(
                text="● ffmpeg не е намерен — кликни тук, за да го посочиш ръчно",
                text_color="#f27070")
            self.log("ffmpeg не е намерен. Кликни върху статус лентата долу, "
                     "за да посочиш ffmpeg.exe ръчно.", "err")
        self.main_btn.configure(state="normal", text="Стартирай обработката")

    def _choose_ffmpeg(self, _event=None):
        if IS_WINDOWS:
            ft = [("Изпълними файлове", "*.exe"), ("Всички файлове", "*.*")]
        else:
            ft = [("Всички файлове", "*")]
        p = filedialog.askopenfilename(title="Избери ffmpeg изпълним файл", filetypes=ft)
        if not p:
            return
        path, ver = locate_ffmpeg(p)
        if path:
            self.ffmpeg_path = path
            self.settings["ffmpeg_path"] = path
            self.ffmpeg_status.configure(text=f"● ffmpeg {ver}", text_color="#6fce6f")
            self.log(f"ffmpeg е зададен: {path}", "ok")
        else:
            messagebox.showerror(APP_NAME, "Избраният файл не е работещ ffmpeg.")

    def _prompt_ffmpeg_missing(self):
        msg = ("ffmpeg не е намерен на този компютър.\n\n"
               "1. Изтегли „release essentials“ от:\n"
               "      https://www.gyan.dev/ffmpeg/builds/\n"
               "2. Разархивирай например в C:\\ffmpeg\n"
               "3. Добави C:\\ffmpeg\\bin към PATH\n\n"
               "Или кликни върху статус лентата долу и посочи ffmpeg.exe ръчно.\n\n"
               "Да отворя избора на файл сега?")
        if messagebox.askyesno(APP_NAME, msg):
            self._choose_ffmpeg()

    # ---------- настройки / затваряне ----------

    def _collect_settings(self) -> dict:
        p = self._params_now()
        if p is None:
            p = (self.settings["target_lufs"], self.settings["true_peak"], self.settings["lra"])
        s = dict(self.settings)
        s.update({
            "target_lufs": p[0], "true_peak": p[1], "lra": p[2],
            "bitrate": BITRATES.get(self.bitrate_combo.get(), self.settings["bitrate"]),
            "recursive": bool(self.recursive_var.get()),
            "backup": bool(self.backup_var.get()),
            "skip_normalized": bool(self.skip_var.get()),
            "clean_names": bool(self.clean_names_var.get()),
            "clean_title_tag": bool(self.clean_tag_var.get()),
            "clean_patterns": self.clean_patterns_entry.get().strip(),
            "last_folder": self._clean_folder() or self.settings.get("last_folder", ""),
            "geometry": self.geometry(),
        })
        return s

    def _on_close(self):
        if self._running:
            if not messagebox.askyesno(APP_NAME, "Обработката е активна.\n"
                                                 "Да спря ли текущата работа и да изляза?"):
                return
            self.cancel_event.set()
        try:
            save_settings(self._collect_settings())
        except Exception:
            pass
        self.destroy()


# ====================== СТАРТ ======================

def main():
    if not GUI_AVAILABLE:
        print("Липсва библиотеката customtkinter. Инсталирай я с:  pip install customtkinter")
        sys.exit(1)
    ctk.set_appearance_mode("Dark")
    ctk.set_default_color_theme("blue")
    app = App(load_settings())
    app.mainloop()


if __name__ == "__main__":
    main()

Заключение

MP3 Balance започна като скрипт от десетина реда и постепенно се превърна в нещо, на което вече имам доверие да пипа колекцията ми. Най-важното за мен е, че не губи данни: има резервни копия, атомарна замяна и безопасно спиране. Втората ключова част е режимът „Само анализ“, който ти показва какво ще стане, преди да стане.

Ако ти хрумне подобрение или попаднеш на файл, с който скриптът се справя странно, пиши ми. Такива случаи най-много ме учат.

← По-нова статия
Калкулатор от командния ред: bc команда в Linux

Подобни статии