v0.99.0: Boost Volume amplifies a quiet song's file up to a typical song's loudness (says how many dB and whether it clips; Edit ▸ Undo puts the original back), replacing the per-song Volume Adjustment, which could never play past full volume

This commit is contained in:
2026-11-19 22:51:16 -08:00
parent f52dd7f567
commit a7d061b200
10 changed files with 783 additions and 196 deletions
+15 -7
View File
@@ -139,13 +139,21 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
without recursing. Widgets react to its signals (`playlists_changed`, without recursing. Widgets react to its signals (`playlists_changed`,
`playlist_content_changed(pid)`, `track_updated(id)`, `track_fields_edited`). `playlist_content_changed(pid)`, `track_updated(id)`, `track_fields_edited`).
- **Per-track volume** (Round 79): `Track.volume_adjustment` is iTunes' - **Boost Volume** (Round 131, `boost.py`; Get Info's button and the
"Volume Adjustment", imported as-is (±255 = ±100%) and edited in Get Info. right-click menu) replaced Round 79's per-track Volume Adjustment, which
`player.volume_with_adjustment` scales the slider's *perceptual* level by scaled the slider and so could never play past full — with the slider up
it: −100% is silence, and a boost can't pass full. `Player` applies it it did nothing (normalization has the same ceiling for quiet songs). The
through `_output_volume()` everywhere it pushes volume to a sink, before file itself is amplified once: ebur128 measures integrated loudness and
each load, and on `refresh_volume()` (MainWindow calls that when the true peak, the target is a *typical* song (`LoudnessAnalyzer.typical_lufs`,
playing track is edited). `Player.volume()` stays the bare slider value. the median measured), the clean limit is the true peak to −1 dBTP; when
typical needs more, the warning offers both (clean, or all the way and
clipping — trav wants iTunes' clipping boost available). ffmpeg rewrites
the same format (MP3 at V0, AAC 320k, lossless as itself), tags and art
copied, staged in `lossless.staging_root()`, then
`replace_track_files(…, in_place=True)` trashes the original and puts the
boosted file at the same path — one undo step. A boost of the playing song
`Player.reopen_current()`s it where it was (no new listen).
`Track.volume_adjustment` is still imported and stored but nothing reads it.
- **Volume normalization** (Round 83, `loudness.py`, Controls → Normalize - **Volume normalization** (Round 83, `loudness.py`, Controls → Normalize
Volume / Preferences → General): each file's EBU R128 integrated loudness Volume / Preferences → General): each file's EBU R128 integrated loudness
+1 -1
View File
@@ -1,3 +1,3 @@
"""LinTunes — iTunes-style music library manager and player for Linux.""" """LinTunes — iTunes-style music library manager and player for Linux."""
__version__ = "0.98.1" __version__ = "0.99.0"
+245
View File
@@ -0,0 +1,245 @@
"""Boost Volume (Round 131): make a too-quiet song as loud as the rest, in
the file itself.
Why in the file: the player can't play louder than the file (Qt's output
volume stops at 1.0), so neither iTunes' old per-song Volume Adjustment nor
volume normalization could lift a quiet song while the main volume was up —
and turning the laptop up for it blasted the next one. So the song's audio is
amplified once, by the ``ffmpeg`` CLI, and saved.
How much: up to a *typical* song's loudness (the median of every song the
normalizer has measured, ``LoudnessAnalyzer.typical_lufs``), measured as EBU
R128 integrated loudness. How much it can take *cleanly* is its true peak's
distance from ``CEILING_DBTP``. When the typical level needs more than that,
the caller offers both: as loud as it goes without clipping, or all the way,
clipping — iTunes' boost clipped, and sometimes loud is the point.
The file keeps its name, format and tags (mutagen copies them and the art,
as Convert to MP3 does); a lossy one is re-encoded at a high setting (MP3 at
V0) so the second generation costs as little as it can. The library swaps
files through ``LibraryManager.replace_track_files``: the original goes to
the trash, Edit ▸ Undo puts it back.
Shaped like ``loudness.py``: pure parsing and planning first, then the
subprocesses, then ``BoostWorker`` on a daemon thread.
"""
from __future__ import annotations
import logging
import re
import subprocess
import tempfile
import threading
from dataclasses import dataclass
from pathlib import Path
from PyQt6.QtCore import QObject, pyqtSignal
from lintunes import loudness
from lintunes.importers import lossless
log = logging.getLogger(__name__)
CEILING_DBTP = -1.0 # true-peak headroom a clean boost keeps (lossy decoders overshoot)
MIN_BOOST_DB = 0.5 # less is inaudible: not worth a re-encode
MAX_BOOST_DB = 30.0 # sanity: past this it's a near-silent file, all hiss
_INTEGRATED = re.compile(r"Integrated loudness:\s*\n\s*I:\s*(-?[\d.]+|-inf)\s*LUFS")
_TRUE_PEAK = re.compile(r"True peak:\s*\n\s*Peak:\s*(-?[\d.]+|-inf)\s*dBFS")
def parse_measurement(output: str) -> tuple[float | None, float | None]:
"""``(integrated LUFS, true peak dBTP)`` from ffmpeg's ebur128 summary
(run with ``peak=true``); either is None when absent or silent."""
lufs = loudness.parse_ebur128(output)
match = _TRUE_PEAK.search(output)
peak = None
if match and match.group(1) != "-inf":
peak = float(match.group(1))
return lufs, peak
@dataclass
class Plan:
"""What a boost of one song would do."""
lufs: float | None # how loud it is now
peak: float | None # its true peak now, dBTP
target_db: float # gain to a typical song's loudness
clean_db: float # the most it can take without clipping
@property
def measurable(self) -> bool:
return self.lufs is not None and self.peak is not None
@property
def clips(self) -> bool:
"""Reaching the typical loudness would clip."""
return self.target_db > self.clean_db + 0.05
@property
def clean_gain(self) -> float:
"""The boost that gets as close to typical as it can, unclipped."""
return max(0.0, min(self.target_db, self.clean_db))
@property
def worth_it(self) -> bool:
return self.measurable and self.target_db >= MIN_BOOST_DB
def plan(lufs: float | None, peak: float | None, typical_lufs: float) -> Plan:
if lufs is None or peak is None:
return Plan(lufs, peak, 0.0, 0.0)
target = max(0.0, min(MAX_BOOST_DB, typical_lufs - lufs))
clean = max(0.0, min(MAX_BOOST_DB, CEILING_DBTP - peak))
return Plan(lufs, peak, round(target, 1), round(clean, 1))
def encoder_args(path: Path, codec: str | None) -> list[str] | None:
"""ffmpeg's output codec options to write ``path``'s format again, or
None for a format this can't rewrite. Lossy formats get their best
setting, since this is a second generation."""
suffix = path.suffix.lower()
if suffix == ".mp3":
return ["-c:a", "libmp3lame", "-q:a", "0", "-id3v2_version", "3"]
if suffix in (".m4a", ".mp4", ".aac"):
if codec == "alac":
return ["-c:a", "alac"]
if codec == "aac":
return ["-c:a", "aac", "-b:a", "320k"]
return None # protected AAC, or something unexpected
if suffix == ".flac":
return ["-c:a", "flac"]
if suffix == ".wav":
return ["-c:a", "pcm_s16le"]
if suffix in (".aiff", ".aif"):
return ["-c:a", "pcm_s16be"]
if suffix == ".ogg":
return ["-c:a", "libvorbis", "-q:a", "8"]
if suffix == ".opus":
return ["-c:a", "libopus", "-b:a", "256k"]
return None
def ffmpeg_command(src: Path, dest: Path, gain_db: float,
codec_args: list[str]) -> list[str]:
"""Audio only (art is copied afterwards with the tags), amplified."""
return ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
"-nostats", "-y", "-i", str(src), "-vn", "-map", "0:a:0",
"-af", f"volume={gain_db:.2f}dB", *codec_args, str(dest)]
# ---- subprocesses ----
def measure(path: str) -> tuple[float | None, float | None]:
"""Decode the whole file once through ebur128 with true peak."""
try:
result = subprocess.run(
["ffmpeg", "-nostdin", "-nostats", "-hide_banner", "-i", path,
"-map", "0:a:0", "-af", "ebur128=peak=true:framelog=quiet",
"-f", "null", "-"],
capture_output=True, text=True, errors="replace", timeout=300)
except (OSError, subprocess.SubprocessError) as exc:
log.info("boost: couldn't measure %s: %s", path, exc)
return None, None
return parse_measurement(result.stderr)
def probe_codec(path: str) -> str | None:
try:
result = subprocess.run(
["ffprobe", "-v", "error", "-select_streams", "a:0",
"-show_entries", "stream=codec_name", "-of", "csv=p=0", path],
capture_output=True, text=True, timeout=30)
except (OSError, subprocess.SubprocessError):
return None
return result.stdout.strip() or None
def amplify(src: Path, dest: Path, gain_db: float):
"""Write ``src`` amplified by ``gain_db`` to ``dest`` (same format),
tags and art copied. Raises OSError on failure; ``src`` is only read."""
codec_args = encoder_args(src, probe_codec(str(src)))
if codec_args is None:
raise OSError(f"can't rewrite a {src.suffix or 'suffixless'} file")
result = subprocess.run(ffmpeg_command(src, dest, gain_db, codec_args),
capture_output=True, text=True, errors="replace",
timeout=900)
if result.returncode != 0 or not dest.exists():
dest.unlink(missing_ok=True)
lines = [l for l in result.stderr.splitlines() if l.strip()]
raise OSError("ffmpeg failed" + (f": {lines[-1]}" if lines else ""))
lossless.copy_tags(src, dest)
class BoostWorker(QObject):
"""Measures songs, then (once told how much) amplifies them, on a daemon
thread. Works from ``(track id, path)`` snapshots, never the library.
``measured`` carries ``{track id: Plan}``; ``amplified`` carries
``[(track id, staged file)]`` plus ``[(track id, reason)]`` failures.
The caller removes ``tmp_dir`` when it's done with the staged files."""
measured = pyqtSignal(dict)
progress = pyqtSignal(str)
amplified = pyqtSignal(list, list)
def __init__(self, items: list[tuple[int, str, str]], typical_lufs: float,
parent=None, measure_fn=None, amplify_fn=None):
super().__init__(parent)
self._items = list(items) # (track id, path, display name)
self._typical = typical_lufs
self._measure = measure_fn or measure
self._amplify = amplify_fn or amplify
self.tmp_dir: Path | None = None
self._busy = False
def busy(self) -> bool:
return self._busy
def start_measuring(self):
self._start(self._run_measure)
def start_amplifying(self, gains: dict[int, float]):
self._start(lambda: self._run_amplify(gains))
def _start(self, target):
self._busy = True
def run():
try:
target()
finally:
self._busy = False
threading.Thread(target=run, daemon=True).start()
def _run_measure(self):
plans = {}
for n, (tid, path, name) in enumerate(self._items, 1):
self.progress.emit(f"Measuring {self._which(n, name)}")
plans[tid] = plan(*self._measure(path), self._typical)
self.measured.emit(plans)
def _run_amplify(self, gains: dict[int, float]):
root = lossless.staging_root()
root.mkdir(parents=True, exist_ok=True)
self.tmp_dir = Path(tempfile.mkdtemp(prefix="boost-", dir=root))
done, failed = [], []
todo = [item for item in self._items if item[0] in gains]
for n, (tid, path, name) in enumerate(todo, 1):
self.progress.emit(f"Amplifying {self._which(n, name, len(todo))}")
src = Path(path)
dest = self.tmp_dir / f"{tid}" / src.name
dest.parent.mkdir(parents=True, exist_ok=True)
try:
self._amplify(src, dest, gains[tid])
except Exception as e:
log.warning("boost: %s: %s", path, e)
failed.append((tid, str(e)))
continue
done.append((tid, dest))
self.amplified.emit(done, failed)
def _which(self, n: int, name: str, total: int | None = None) -> str:
total = total if total is not None else len(self._items)
name = name if len(name) <= 40 else name[:39] + "…"
return name if total == 1 else f"{n} of {total} · {name}"
+19 -51
View File
@@ -12,7 +12,6 @@ from PyQt6.QtGui import QPixmap, QImage, QKeySequence, QShortcut
from lintunes import tagging from lintunes import tagging
from lintunes.gui.art_ops import embed_artwork from lintunes.gui.art_ops import embed_artwork
from lintunes.player import VOLUME_ADJUSTMENT_MAX
from lintunes.gui.file_filters import IMAGE_FILTER from lintunes.gui.file_filters import IMAGE_FILTER
from lintunes.gui.track_table import key_hint from lintunes.gui.track_table import key_hint
@@ -293,12 +292,14 @@ class InfoDialog(QDialog):
"""iTunes-style Get Info: edits library fields and the file's real tags. """iTunes-style Get Info: edits library fields and the file's real tags.
Single track: custom start/stop times and the file's path, besides the Single track: custom start/stop times and the file's path, besides the
fields every mode has (incl. Volume, iTunes' per-song volume adjustment). fields every mode has. Multiple tracks: a combined
Multiple tracks: a combined
editor where fields shared by every selection are editable and applied to editor where fields shared by every selection are editable and applied to
all, while fields that differ show "Mixed" and are only written if touched. all, while fields that differ show "Mixed" and are only written if touched.
Boost Volume… acts at once rather than on OK: ``boost_requested``.
""" """
boost_requested = pyqtSignal(list) # track ids
def __init__(self, manager, track_ids: list[int], parent=None): def __init__(self, manager, track_ids: list[int], parent=None):
super().__init__(parent) super().__init__(parent)
self._manager = manager self._manager = manager
@@ -377,25 +378,18 @@ class InfoDialog(QDialog):
form.addRow("", self._start_row) form.addRow("", self._start_row)
form.addRow("", self._stop_row) form.addRow("", self._stop_row)
# Volume adjustment: iTunes' own (imported as-is), ±255 = ±100%. # Boost Volume (Round 131) replaced iTunes' Volume Adjustment slider,
# which could never play past full volume. It amplifies the file
# itself, at once, as its own undo step; MainWindow does the work.
volume_row = QHBoxLayout() volume_row = QHBoxLayout()
self._volume = QSlider(Qt.Orientation.Horizontal) self._boost_button = QPushButton("Boost Volume…")
self._volume.setRange(-100, 100) self._boost_button.setToolTip(
self._volume.setPageStep(10) "Make a quiet song as loud as a typical one by amplifying the "
self._volume.setTickPosition(QSlider.TickPosition.TicksBelow) "file itself. Edit ▸ Undo puts the original back.")
self._volume.setTickInterval(50) self._boost_button.setAutoDefault(False)
self._volume.setToolTip( self._boost_button.clicked.connect(self._on_boost)
"Make this song quieter or louder than the rest. A boost can't " volume_row.addWidget(self._boost_button)
"go past full volume, so it only helps while the main volume " volume_row.addStretch(1)
"isn't all the way up.")
self._volume_label = QLabel()
self._volume_label.setMinimumWidth(QLabel("Mixed").sizeHint().width() + 8)
self._volume.valueChanged.connect(self._on_volume_moved)
volume_row.addWidget(QLabel("−100%"))
volume_row.addWidget(self._volume, stretch=1)
volume_row.addWidget(QLabel("+100%"))
volume_row.addSpacing(6)
volume_row.addWidget(self._volume_label)
form.addRow("Volume:", volume_row) form.addRow("Volume:", volume_row)
self._file_label = QLabel() self._file_label = QLabel()
@@ -489,7 +483,6 @@ class InfoDialog(QDialog):
self._stop_time.setEnabled(track.stop_time > 0) self._stop_time.setEnabled(track.stop_time > 0)
self._stop_time.set_ms(track.stop_time) self._stop_time.set_ms(track.stop_time)
self._file_label.setText(track.location or "") self._file_label.setText(track.location or "")
self._set_volume_slider(track.volume_adjustment or 0)
self._loading = False self._loading = False
def _load_multi(self): def _load_multi(self):
@@ -522,9 +515,6 @@ class InfoDialog(QDialog):
self._comments.setPlainText("") self._comments.setPlainText("")
else: else:
self._comments.setPlainText(comments or "") self._comments.setPlainText(comments or "")
volume = self._common_value("volume_adjustment")
self._set_volume_slider(0 if volume is _MIXED else (volume or 0),
mixed=volume is _MIXED)
self._loading = False self._loading = False
def _collect_fields(self) -> dict: def _collect_fields(self) -> dict:
@@ -539,7 +529,6 @@ class InfoDialog(QDialog):
if self._start_check.isChecked() else 0) if self._start_check.isChecked() else 0)
fields["stop_time"] = (self._stop_time.ms() fields["stop_time"] = (self._stop_time.ms()
if self._stop_check.isChecked() else 0) if self._stop_check.isChecked() else 0)
fields["volume_adjustment"] = self._volume_adjustment()
return fields return fields
def _validate_times(self, track) -> str | None: def _validate_times(self, track) -> str | None:
@@ -591,8 +580,6 @@ class InfoDialog(QDialog):
fields["compilation"] = self._compilation.isChecked() fields["compilation"] = self._compilation.isChecked()
if "comments" in self._touched: if "comments" in self._touched:
fields["comments"] = self._comments.toPlainText().strip() fields["comments"] = self._comments.toPlainText().strip()
if "volume_adjustment" in self._touched:
fields["volume_adjustment"] = self._volume_adjustment()
if self._staged_art is not None: if self._staged_art is not None:
tracks = [self._manager.library.tracks[tid] tracks = [self._manager.library.tracks[tid]
for tid in self._track_ids] for tid in self._track_ids]
@@ -616,29 +603,10 @@ class InfoDialog(QDialog):
# ---- volume ---- # ---- volume ----
def _set_volume_slider(self, adjustment: int, mixed: bool = False): def _on_boost(self):
self._volume.setValue(round(100 * adjustment / VOLUME_ADJUSTMENT_MAX)) ids = (list(self._track_ids) if self._multi
self._show_volume(mixed) else [self._current_track().track_id])
self.boost_requested.emit(ids)
def _volume_adjustment(self) -> int:
"""The slider in iTunes' unit. A value the slider shows unchanged
keeps its exact stored number (±1 % is 2–3 units)."""
position = self._volume.value()
if not self._multi:
stored = self._current_track().volume_adjustment or 0
if round(100 * stored / VOLUME_ADJUSTMENT_MAX) == position:
return stored
return round(position * VOLUME_ADJUSTMENT_MAX / 100)
def _on_volume_moved(self, _value):
if not self._loading:
self._mark_touched("volume_adjustment")
self._show_volume(mixed=False)
def _show_volume(self, mixed: bool):
value = self._volume.value()
self._volume_label.setText(
"Mixed" if mixed else "None" if value == 0 else f"{value:+d}%")
def _on_ok(self): def _on_ok(self):
saved = self._save_multi() if self._multi else self._save_current() saved = self._save_multi() if self._multi else self._save_current()
+163 -2
View File
@@ -1,3 +1,4 @@
import logging
import shutil import shutil
import threading import threading
from pathlib import Path from pathlib import Path
@@ -316,6 +317,8 @@ class MainWindow(QMainWindow):
# A compressing import (gui/compress_import.py), from start until # A compressing import (gui/compress_import.py), from start until
# Done or Cancel — which can be after its worker has finished. # Done or Cancel — which can be after its worker has finished.
self._compress = None self._compress = None
self._boost = None # boost.BoostWorker while one runs
self._boost_typical = 0.0
self._compress_reload = QTimer(self) self._compress_reload = QTimer(self)
self._compress_reload.setSingleShot(True) self._compress_reload.setSingleShot(True)
self._compress_reload.setInterval(400) self._compress_reload.setInterval(400)
@@ -388,6 +391,7 @@ class MainWindow(QMainWindow):
view.table.identify_requested.connect(self._identify_tracks) view.table.identify_requested.connect(self._identify_tracks)
view.table.bpm_requested.connect(self._calculate_bpm) view.table.bpm_requested.connect(self._calculate_bpm)
view.table.convert_requested.connect(self._convert_to_mp3) view.table.convert_requested.connect(self._convert_to_mp3)
view.table.boost_requested.connect(self._boost_volume)
view.table.dj_prepare_requested.connect(self._prepare_for_dj) view.table.dj_prepare_requested.connect(self._prepare_for_dj)
view.table.remove_from_library_requested.connect( view.table.remove_from_library_requested.connect(
lambda ids: self._delete_tracks(ids, delete_files=False)) lambda ids: self._delete_tracks(ids, delete_files=False))
@@ -1714,7 +1718,9 @@ class MainWindow(QMainWindow):
def _show_info(self, track_ids: list[int]): def _show_info(self, track_ids: list[int]):
if track_ids: if track_ids:
InfoDialog(self._manager, track_ids, self).exec() dialog = InfoDialog(self._manager, track_ids, self)
dialog.boost_requested.connect(self._boost_volume)
dialog.exec()
def _info_for_current_view(self): def _info_for_current_view(self):
view = self._content.currentWidget() view = self._content.currentWidget()
@@ -1902,6 +1908,162 @@ class MainWindow(QMainWindow):
if "cancelled" not in message: if "cancelled" not in message:
sounds.play_done(self._prefs) sounds.play_done(self._prefs)
# ---- Boost Volume (Round 131, lintunes/boost.py) ----
def _boost_volume(self, track_ids: list[int]):
"""Right-click or Get Info › Boost Volume…: measure, say what it
would do, amplify the files, swap them in as one undo step."""
from lintunes import boost
if not lossless.ffmpeg_available():
QMessageBox.warning(
QApplication.activeWindow() or self, "Boost Volume",
"Boosting needs ffmpeg, which is not installed.\n\n"
"Install your distro's “ffmpeg” package and try again.")
return
if self._boost is not None:
self.statusBar().showMessage(
"Wait for the current boost to finish first", 6000)
return
tracks = [self._manager.library.tracks[t] for t in track_ids
if t in self._manager.library.tracks]
tracks = [t for t in tracks if t.location and Path(t.location).exists()]
if not tracks:
self.statusBar().showMessage("No song file to boost", 6000)
return
analyzer = getattr(self.player, "loudness", None)
typical = (analyzer.typical_lufs() if analyzer is not None
else loudness.TYPICAL_LUFS)
worker = boost.BoostWorker(
[(t.track_id, t.location, t.name or Path(t.location).stem)
for t in tracks], typical, self)
self._boost = worker
self._boost_typical = typical
worker.progress.connect(lambda text: self.statusBar().showMessage(text))
worker.measured.connect(self._on_boost_measured)
worker.amplified.connect(self._on_boost_amplified)
worker.start_measuring()
def _boost_end(self, message: str = ""):
worker, self._boost = self._boost, None
if worker is not None and worker.tmp_dir is not None:
shutil.rmtree(worker.tmp_dir, ignore_errors=True)
if message:
self.statusBar().showMessage(message, 8000)
else:
self.statusBar().clearMessage()
def _on_boost_measured(self, plans: dict):
gains = self._ask_boost(plans)
if not gains:
self._boost_end()
return
self._boost.start_amplifying(gains)
def _ask_boost(self, plans: dict) -> dict:
"""The warning before anything changes: how many dB, and whether it
clips. ``{track id: gain dB}`` to apply, empty for none."""
from lintunes import boost
parent = QApplication.activeWindow() or self
tracks = self._manager.library.tracks
name = lambda tid: f"“{tracks[tid].name}”" if tid in tracks else "This song"
typical = self._boost_typical
unmeasurable = [t for t, p in plans.items() if not p.measurable]
loud = [t for t, p in plans.items() if p.measurable and not p.worth_it]
todo = {t: p for t, p in plans.items() if p.worth_it}
if not todo:
if unmeasurable and not loud:
text = (f"{name(unmeasurable[0])} couldn't be measured — it "
"may be silent or unreadable." if len(plans) == 1 else
"None of those songs could be measured.")
elif len(plans) == 1:
p = plans[loud[0]]
text = (f"{name(loud[0])} is already as loud as a typical song "
f"({p.lufs:.1f} LUFS; typical is {typical:.1f}) — "
"nothing to boost.")
else:
text = "Those songs are already as loud as a typical song."
QMessageBox.information(parent, "Boost Volume", text)
return {}
undo_note = ("The original goes to the trash; Edit ▸ Undo puts it back."
if len(todo) == 1 else
"The originals go to the trash; Edit ▸ Undo puts them all back.")
box = QMessageBox(parent)
box.setWindowTitle("Boost Volume")
box.setIcon(QMessageBox.Icon.Question)
clipping = {t: p for t, p in todo.items() if p.clips}
if len(todo) == 1:
tid, p = next(iter(todo.items()))
if not p.clips:
box.setText(f"{name(tid)} will be amplified {p.target_db:+.1f} dB, "
"to a typical song's loudness, and will not clip.")
else:
box.setText(
f"{name(tid)} needs {p.target_db:+.1f} dB to be as loud as "
f"a typical song, which would clip it. Without clipping it "
f"can be amplified {p.clean_gain:+.1f} dB.")
else:
lines = [f"{name(t)}: {p.target_db:+.1f} dB"
+ (f" (clips; {p.clean_gain:+.1f} dB without)" if p.clips else "")
for t, p in todo.items()]
skipped = len(loud) + len(unmeasurable)
box.setText(f"{len(todo)} songs will be amplified to a typical "
"song's loudness" + (" — some would clip:" if clipping
else ", and none will clip:"))
box.setDetailedText("\n".join(lines))
box.setInformativeText(
"\n".join(lines[:8]) + ("\n…" if len(lines) > 8 else "")
+ (f"\n\n{skipped} already loud enough or unmeasurable, left as they are."
if skipped else "") + "\n\n" + undo_note)
if len(todo) == 1:
box.setInformativeText(undo_note)
full = clean = None
if not clipping:
full = box.addButton("Amplify", QMessageBox.ButtonRole.AcceptRole)
box.setDefaultButton(full)
else:
if len(todo) == 1:
p = next(iter(todo.values()))
if p.clean_gain >= boost.MIN_BOOST_DB:
clean = box.addButton(f"Amplify {p.clean_gain:+.1f} dB",
QMessageBox.ButtonRole.AcceptRole)
full = box.addButton(f"Amplify {p.target_db:+.1f} dB (clips)",
QMessageBox.ButtonRole.AcceptRole)
else:
clean = box.addButton("Amplify Without Clipping",
QMessageBox.ButtonRole.AcceptRole)
full = box.addButton("Amplify All the Way (clips)",
QMessageBox.ButtonRole.AcceptRole)
box.setDefaultButton(clean or full)
box.addButton(QMessageBox.StandardButton.Cancel)
box.exec()
chosen = box.clickedButton()
if chosen is full:
return {t: p.target_db for t, p in todo.items()}
if chosen is clean:
return {t: p.clean_gain for t, p in todo.items()
if p.clean_gain >= boost.MIN_BOOST_DB}
return {}
def _on_boost_amplified(self, done: list, failed: list):
try:
failures = self._manager.replace_track_files(
done, label="Boost Volume", in_place=True)
except Exception as e: # never leave the boost stuck "running"
logging.getLogger(__name__).exception("Boost Volume failed")
self._boost_end(f"Boost Volume failed: {e}")
return
current = self.player.current_track
if current is not None and any(tid == current.track_id for tid, _ in done):
self.player.reopen_current()
n = len(done) - len(failures)
text = (f"Boosted {n} song{'s' if n != 1 else ''} · Edit ▸ Undo puts "
f"{'it' if n == 1 else 'them'} back" if n else "Nothing was boosted")
problems = len(failed) + len(failures)
if problems:
first = failed[0][1] if failed else failures[0][1]
text += f" · {problems} couldn't be ({first})"
self._boost_end(text)
def _convert_to_mp3(self, track_ids: list[int]): def _convert_to_mp3(self, track_ids: list[int]):
"""Right-click › Convert to MP3…: shrink lossless songs already in """Right-click › Convert to MP3…: shrink lossless songs already in
the library (gui/compress_import.ConvertLibrary).""" the library (gui/compress_import.ConvertLibrary)."""
@@ -3386,7 +3548,6 @@ class MainWindow(QMainWindow):
current = self.player.current_track current = self.player.current_track
if current is not None and current.track_id == track_id: if current is not None and current.track_id == track_id:
self._sidebar.art.refresh() self._sidebar.art.refresh()
self.player.refresh_volume() # its volume adjustment may have moved
def _update_now_playing_icon(self, _playing=None): def _update_now_playing_icon(self, _playing=None):
track = self.player.current_track track = self.player.current_track
+7
View File
@@ -800,6 +800,7 @@ class TrackTableView(QTableView):
identify_requested = pyqtSignal(list) # selected track ids identify_requested = pyqtSignal(list) # selected track ids
bpm_requested = pyqtSignal(list) # selected track ids bpm_requested = pyqtSignal(list) # selected track ids
convert_requested = pyqtSignal(list) # selected track ids (to MP3) convert_requested = pyqtSignal(list) # selected track ids (to MP3)
boost_requested = pyqtSignal(list) # selected track ids (Boost Volume)
dj_prepare_requested = pyqtSignal(list) # selected track ids dj_prepare_requested = pyqtSignal(list) # selected track ids
remove_from_library_requested = pyqtSignal(list) # track ids, file kept remove_from_library_requested = pyqtSignal(list) # track ids, file kept
delete_from_library_requested = pyqtSignal(list) # track ids, file trashed delete_from_library_requested = pyqtSignal(list) # track ids, file trashed
@@ -1133,6 +1134,7 @@ class TrackTableView(QTableView):
locations = self.selected_locations() locations = self.selected_locations()
reveal_action = copy_path_action = download_art_action = None reveal_action = copy_path_action = download_art_action = None
identify_action = bpm_action = dj_action = convert_action = None identify_action = bpm_action = dj_action = convert_action = None
boost_action = None
if locations: if locations:
menu.addSeparator() menu.addSeparator()
reveal_action = menu.addAction( reveal_action = menu.addAction(
@@ -1142,6 +1144,9 @@ class TrackTableView(QTableView):
# Fingerprinting reads the audio, so this needs a file on disk. # Fingerprinting reads the audio, so this needs a file on disk.
identify_action = menu.addAction("Identify Track…") identify_action = menu.addAction("Identify Track…")
bpm_action = menu.addAction("Calculate BPM") bpm_action = menu.addAction("Calculate BPM")
boost_action = menu.addAction("Boost Volume…")
boost_action.setToolTip("Amplify a quiet song's file up to a "
"typical song's loudness")
dj_action = menu.addAction("Prepare for DJ") dj_action = menu.addAction("Prepare for DJ")
dj_action.setToolTip("Work out BPM and separate vocals now, so " dj_action.setToolTip("Work out BPM and separate vocals now, so "
"these load instantly onto a deck") "these load instantly onto a deck")
@@ -1205,6 +1210,8 @@ class TrackTableView(QTableView):
self.identify_requested.emit(self.selected_track_ids()) self.identify_requested.emit(self.selected_track_ids())
elif bpm_action is not None and chosen is bpm_action: elif bpm_action is not None and chosen is bpm_action:
self.bpm_requested.emit(self.selected_track_ids()) self.bpm_requested.emit(self.selected_track_ids())
elif boost_action is not None and chosen is boost_action:
self.boost_requested.emit(self.selected_track_ids())
elif convert_action is not None and chosen is convert_action: elif convert_action is not None and chosen is convert_action:
self.convert_requested.emit(self.selected_track_ids()) self.convert_requested.emit(self.selected_track_ids())
elif dj_action is not None and chosen is dj_action: elif dj_action is not None and chosen is dj_action:
+24 -4
View File
@@ -1,6 +1,7 @@
import logging import logging
import os import os
import secrets import secrets
import shutil
import unicodedata import unicodedata
from datetime import datetime, timezone from datetime import datetime, timezone
from pathlib import Path from pathlib import Path
@@ -751,7 +752,9 @@ class LibraryManager(QObject):
_FILE_FIELDS = ("location", "kind", "bit_rate", "sample_rate", "size", _FILE_FIELDS = ("location", "kind", "bit_rate", "sample_rate", "size",
"total_time") "total_time")
def replace_track_files(self, changes: list[tuple[int, Path]]) -> list: def replace_track_files(self, changes: list[tuple[int, Path]],
label: str = "Convert to MP3",
in_place: bool = False) -> list:
"""Convert to MP3 (Round 107): each track now plays ``new_path``, a """Convert to MP3 (Round 107): each track now plays ``new_path``, a
converted copy of its file, and the old file goes to the desktop converted copy of its file, and the old file goes to the desktop
trash. Same track — play counts, playlists and ratings don't move. trash. Same track — play counts, playlists and ratings don't move.
@@ -759,8 +762,12 @@ class LibraryManager(QObject):
the source of truth. ONE undoable command for the batch: undo brings the source of truth. ONE undoable command for the batch: undo brings
the originals back from the trash and trashes the copies. the originals back from the trash and trashes the copies.
``in_place`` (Boost Volume, Round 131): ``new_path`` is a staged
file that takes the original's own path once the original is in the
trash — same name, same format.
Returns ``(name, error)`` per track left as it was (its new file is Returns ``(name, error)`` per track left as it was (its new file is
trashed again, so nothing is left lying around).""" trashed again, or left in staging, so nothing is left lying around)."""
records = [] # [track, {"old": fields, "new": fields, "trashed": path}] records = [] # [track, {"old": fields, "new": fields, "trashed": path}]
failures = [] failures = []
for track_id, new_path in changes: for track_id, new_path in changes:
@@ -775,7 +782,8 @@ class LibraryManager(QObject):
except Exception as e: except Exception as e:
log.warning("Couldn't write tags to %s: %s", new_path, e) log.warning("Couldn't write tags to %s: %s", new_path, e)
fields = tagging.read_tags(new_path) fields = tagging.read_tags(new_path)
new = {"location": str(new_path), final = Path(track.location) if in_place else new_path
new = {"location": str(final),
**{k: fields[k] for k in self._FILE_FIELDS[1:] if k in fields}} **{k: fields[k] for k in self._FILE_FIELDS[1:] if k in fields}}
old = {k: getattr(track, k) for k in new} old = {k: getattr(track, k) for k in new}
try: try:
@@ -783,11 +791,23 @@ class LibraryManager(QObject):
except trash.TrashError as e: except trash.TrashError as e:
log.warning("Could not trash %s: %s", track.location, e) log.warning("Could not trash %s: %s", track.location, e)
failures.append((track.name or track.location, str(e))) failures.append((track.name or track.location, str(e)))
if not in_place:
try: try:
trash.send_to_trash(new_path) trash.send_to_trash(new_path)
except trash.TrashError: except trash.TrashError:
pass pass
continue continue
if in_place:
try:
shutil.move(str(new_path), str(final))
except OSError as e:
log.warning("Could not put %s in place: %s", final, e)
failures.append((track.name or track.location, str(e)))
try:
trash.restore_from_trash(trashed, final)
except trash.TrashError:
log.warning("%s is left in the trash", final)
continue
records.append([track, {"old": old, "new": new, "trashed": trashed, records.append([track, {"old": old, "new": new, "trashed": trashed,
"trashed_new": None}]) "trashed_new": None}])
self._apply_track_fields(track_id, new) self._apply_track_fields(track_id, new)
@@ -829,7 +849,7 @@ class LibraryManager(QObject):
for track, r in records: for track, r in records:
swap(track, r, "old", "new") swap(track, r, "old", "new")
self.undo_stack.push(Command("Convert to MP3", undo=undo, redo=redo)) self.undo_stack.push(Command(label, undo=undo, redo=redo))
return failures return failures
def _write_track_tags(self, track, field_map: dict) -> bool: def _write_track_tags(self, track, field_map: dict) -> bool:
+18 -26
View File
@@ -70,21 +70,6 @@ def make_shuffle_order(count: int, start_index: int) -> list[int]:
return order return order
VOLUME_ADJUSTMENT_MAX = 255 # iTunes' unit: ±255 is its slider's ±100%
def volume_with_adjustment(level: float, adjustment: int) -> float:
"""A track's volume adjustment (Get Info → Volume, iTunes' "Volume
Adjustment", imported as-is) applied to the logical 0..1 volume.
It scales the slider's own perceptual level: −100% is silence, +50% is
the slider half again as far up. It can't go past full — no output can —
so a boost only helps while the main volume is below the top, exactly
like iTunes'."""
share = max(-1.0, min(1.0, adjustment / VOLUME_ADJUSTMENT_MAX))
return max(0.0, min(1.0, level * (1.0 + share)))
_LOG100 = math.log(100.0) _LOG100 = math.log(100.0)
@@ -719,18 +704,25 @@ class Player(QObject):
self._volume = max(0.0, min(1.0, float(level))) self._volume = max(0.0, min(1.0, float(level)))
self._sink.set_volume(self._output_volume()) self._sink.set_volume(self._output_volume())
def refresh_volume(self):
"""Re-apply the volume — after the playing track's own volume
adjustment was edited."""
self._sink.set_volume(self._output_volume())
def _output_volume(self) -> float: def _output_volume(self) -> float:
"""The slider's volume with the playing track's adjustment and the """The slider's volume with the normalization gain on it. (Round 131
normalization gain on it.""" retired iTunes' per-song Volume Adjustment here: a boost could never
return volume_with_gain(volume_with_adjustment( pass full volume, so it did nothing with the slider up. Boost Volume
self._volume, amplifies the file instead, ``boost.py``.)"""
getattr(self._current_track, "volume_adjustment", 0) or 0), return volume_with_gain(self._volume, self._gain_db)
self._gain_db)
def reopen_current(self):
"""Load the playing song's file again where it's up to, playing if it
was — after the file under it was replaced (Boost Volume). Not a new
song: no track_changed, the listen carries on."""
track = self._current_track
if track is None or not track.location:
return
position = self._sink.position_ms()
playing = self._sink.is_playing()
self._aim_gain(track, glide=False)
self._sink.set_volume(self._output_volume())
self._sink.load(track, playing, position)
# ---- normalization ---- # ---- normalization ----
+284
View File
@@ -0,0 +1,284 @@
"""Round 131: Boost Volume (lintunes/boost.py) replaces the per-track Volume
Adjustment, which could never play past full volume.
1. Measuring: integrated loudness + true peak from ffmpeg's ebur128.
2. The plan: up to a typical song's loudness, and how far it can go clean.
3. Amplifying writes the same format, tags and art kept, the source only read.
4. The library swaps the file in place as one undo step (original to the
trash; undo puts it back at the same path).
5. The player reopens the playing song where it was, without a new listen.
6. Get Info has a Boost Volume… button and no slider; the right-click menu
and the window run the whole thing.
"""
import shutil
import subprocess
import time
from pathlib import Path
import pytest
from lintunes import boost, tagging
from lintunes.library_manager import LibraryManager
from lintunes.models import Library, Playlist, Track
from lintunes.preferences import Preferences
from tests.test_round29 import _player, _local_track, _FakeSink
@pytest.fixture(autouse=True)
def _staging_in_tmp(tmp_path, monkeypatch):
monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))
monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
@pytest.fixture
def fake_trash(tmp_path, monkeypatch):
bin_ = tmp_path / "trash-bin"
bin_.mkdir()
count = iter(range(10**6)) # a name per send, never reused
def send(path):
path = Path(path)
if not path.exists():
from lintunes.trash import TrashError
raise TrashError(f"{path} doesn't exist")
dest = bin_ / f"{next(count)}-{path.name}"
shutil.move(str(path), dest)
return dest
def restore(trashed, original):
Path(original).parent.mkdir(parents=True, exist_ok=True)
shutil.move(str(trashed), str(original))
monkeypatch.setattr("lintunes.library_manager.trash.send_to_trash", send)
monkeypatch.setattr("lintunes.library_manager.trash.restore_from_trash",
restore)
return bin_
def _quiet_mp3(path: Path, db: float = -20.0, seconds: int = 3) -> Path:
if shutil.which("ffmpeg") is None:
pytest.skip("ffmpeg not available")
path.parent.mkdir(parents=True, exist_ok=True)
subprocess.run(["ffmpeg", "-y", "-f", "lavfi", "-i",
f"sine=f=440:d={seconds},volume={db}dB", "-ac", "2",
"-c:a", "libmp3lame", "-b:a", "128k", str(path)],
capture_output=True, check=True)
tagging.write_tags(path, {"name": "Salivate-ish", "artist": "Quiet Band",
"album": "Hush", "track_number": 4})
tagging.write_artwork(path, _jpeg(), "image/jpeg")
return path
def _jpeg() -> bytes:
from PyQt6.QtCore import QBuffer, QIODevice
from PyQt6.QtGui import QColor, QImage
image = QImage(8, 8, QImage.Format.Format_RGB32)
image.fill(QColor("red"))
buffer = QBuffer()
buffer.open(QIODevice.OpenModeFlag.WriteOnly)
image.save(buffer, "JPG")
return bytes(buffer.data())
SUMMARY = """[Parsed_ebur128_0 @ 0x1] Summary:
Integrated loudness:
I: -28.7 LUFS
Threshold: -39.0 LUFS
Loudness range:
LRA: 5.0 LU
True peak:
Peak: -18.9 dBFS
"""
# ---- 1 & 2 ----
class TestMeasureAndPlan:
def test_parses_loudness_and_true_peak(self):
assert boost.parse_measurement(SUMMARY) == (-28.7, -18.9)
def test_nothing_to_parse(self):
assert boost.parse_measurement("garbage") == (None, None)
def test_a_quiet_song_with_room_goes_all_the_way_clean(self):
p = boost.plan(-28.7, -18.9, -14.0)
assert p.target_db == 14.7 and not p.clips and p.clean_gain == 14.7
def test_when_typical_needs_more_than_the_headroom_it_clips(self):
p = boost.plan(-28.7, -18.9, -10.0)
assert p.target_db == 18.7 and p.clips
assert p.clean_gain == pytest.approx(17.9) # true peak to -1 dBTP
def test_already_loud_is_not_worth_it(self):
assert not boost.plan(-9.0, -0.2, -10.0).worth_it
assert not boost.plan(None, None, -10.0).measurable
def test_a_near_silent_file_is_capped(self):
assert boost.plan(-70.0 + 15, -50.0, -10.0).target_db == boost.MAX_BOOST_DB
def test_formats(self):
assert boost.encoder_args(Path("a.mp3"), "mp3")[:2] == ["-c:a", "libmp3lame"]
assert boost.encoder_args(Path("a.m4a"), "alac") == ["-c:a", "alac"]
assert boost.encoder_args(Path("a.m4a"), "aac")[1] == "aac"
assert boost.encoder_args(Path("a.m4p"), "aac") is None
assert boost.encoder_args(Path("a.m4a"), None) is None # protected?
# ---- 3 ----
def test_amplify_reaches_the_target_and_keeps_tags_and_art(tmp_path):
src = _quiet_mp3(tmp_path / "in" / "q.mp3")
before = src.read_bytes()
lufs, peak = boost.measure(str(src))
p = boost.plan(lufs, peak, -14.0)
assert not p.clips
dest = tmp_path / "out" / "q.mp3"
dest.parent.mkdir()
boost.amplify(src, dest, p.clean_gain)
after, _ = boost.measure(str(dest))
assert after == pytest.approx(-14.0, abs=0.5)
assert src.read_bytes() == before # only read
tags = tagging.read_tags(dest)
assert tags["name"] == "Salivate-ish" and tags["artist"] == "Quiet Band"
assert tagging.read_embedded_artwork(dest)
def test_amplify_refuses_what_it_cant_rewrite(tmp_path):
odd = tmp_path / "x.wma"
odd.write_bytes(b"x")
with pytest.raises(OSError):
boost.amplify(odd, tmp_path / "y.wma", 3.0)
# ---- 4 ----
def _library(tmp_path):
path = _quiet_mp3(tmp_path / "media" / "Music" / "Quiet Band" / "Hush"
/ "04 Salivate-ish.mp3")
fields = tagging.read_tags(path)
library = Library(music_folder=str(tmp_path / "media"))
library.tracks[1] = Track(track_id=1, name="Salivate-ish",
artist="Quiet Band", album="Hush",
location=str(path), play_count=9, rating=80,
size=fields["size"], kind=fields["kind"],
total_time=fields["total_time"])
library.playlists["P"] = Playlist(name="Mix", persistent_id="P",
track_ids=[1])
return LibraryManager(library, tmp_path / "data")
def test_in_place_swap_keeps_the_path_and_undoes(qapp, tmp_path, fake_trash):
manager = _library(tmp_path)
location = manager.library.tracks[1].location
original = Path(location).read_bytes()
staged = tmp_path / "cache" / "boosted" / "04 Salivate-ish.mp3"
staged.parent.mkdir(parents=True)
boost.amplify(Path(location), staged, 10.0)
assert manager.replace_track_files([(1, staged)], label="Boost Volume",
in_place=True) == []
track = manager.library.tracks[1]
boosted = Path(location).read_bytes()
assert track.location == location and boosted != original
assert boost.measure(location)[0] > boost.measure(
str(next(fake_trash.iterdir())))[0] + 9
assert track.play_count == 9 and manager.library.playlists["P"].track_ids == [1]
assert not staged.exists()
assert "Boost Volume" in manager.undo_stack.undo_label()
manager.undo_stack.undo()
assert Path(location).read_bytes() == original
assert manager.library.tracks[1].location == location
manager.undo_stack.redo()
assert Path(location).read_bytes() == boosted
def test_a_failed_trash_leaves_the_song_alone(qapp, tmp_path, monkeypatch):
from lintunes.trash import TrashError
manager = _library(tmp_path)
location = manager.library.tracks[1].location
original = Path(location).read_bytes()
staged = tmp_path / "staged.mp3"
staged.write_bytes(original)
def refuse(_path):
raise TrashError("no trash here")
monkeypatch.setattr("lintunes.library_manager.trash.send_to_trash", refuse)
failures = manager.replace_track_files([(1, staged)], in_place=True)
assert len(failures) == 1 and Path(location).read_bytes() == original
# ---- 5 ----
def test_reopen_current_keeps_place_and_listen(qapp, tmp_path):
track = _local_track(tmp_path, 1)
player = _player(qapp, [track])
sink = _FakeSink()
player.set_sink(sink)
player.play_queue([1], 0)
sink._position = 61_000
changed = []
player.track_changed.connect(changed.append)
player.reopen_current()
assert sink.loads[-1] == (1, True, 61_000)
assert changed == []
def test_the_player_ignores_the_old_adjustment(qapp, tmp_path):
track = _local_track(tmp_path, 1, volume_adjustment=-255)
player = _player(qapp, [track])
sink = _FakeSink()
player.set_sink(sink)
player.set_volume(0.6)
player.play_queue([1], 0)
assert sink.volume == pytest.approx(0.6)
# ---- 6 ----
def test_get_info_has_the_button_not_the_slider(qapp, tmp_path):
from PyQt6.QtWidgets import QPushButton, QSlider
from lintunes.gui.info_dialog import InfoDialog
library = Library()
library.tracks[1] = Track(track_id=1, name="A")
library.tracks[2] = Track(track_id=2, name="B")
manager = LibraryManager(library, tmp_path / "data")
for ids in ([1], [1, 2]):
dialog = InfoDialog(manager, ids)
assert not dialog.findChildren(QSlider)
button = next(b for b in dialog.findChildren(QPushButton)
if b.text() == "Boost Volume…")
asked = []
dialog.boost_requested.connect(asked.append)
button.click()
assert asked == [ids]
def test_window_flow_boosts_and_undoes(qapp, tmp_path, fake_trash, monkeypatch):
from lintunes.gui.main_window import MainWindow
manager = _library(tmp_path)
location = manager.library.tracks[1].location
original = Path(location).read_bytes()
window = MainWindow(manager, Preferences(tmp_path / "data"))
seen = []
monkeypatch.setattr(window, "_ask_boost",
lambda plans: seen.append(plans) or
{t: p.clean_gain for t, p in plans.items()})
try:
window._boost_volume([1])
deadline = time.time() + 30
while window._boost is not None and time.time() < deadline:
qapp.processEvents()
time.sleep(0.02)
assert window._boost is None
assert seen and seen[0][1].worth_it
assert Path(location).read_bytes() != original
lufs, _ = boost.measure(location)
assert lufs > boost.measure(str(next(fake_trash.iterdir())))[0] + 5
assert not list((tmp_path / "cache").rglob("boost-*")) # staging gone
manager.undo_stack.undo()
assert Path(location).read_bytes() == original
finally:
window.close()
+3 -101
View File
@@ -1,10 +1,9 @@
"""Round 79: per-track volume, Get Info tidy-up, Preferences headings, and """Round 79: per-track volume, Get Info tidy-up, Preferences headings, and
the laser rig diagram. the laser rig diagram.
1. A track's volume adjustment (iTunes' "Volume Adjustment", already 1. (Retired in Round 131: the per-track volume adjustment, which could never
imported) scales the output while that track plays. play past full volume; Boost Volume amplifies the file instead.)
2. Get Info edits it — one track or several — and has no dead 2. Get Info has no dead Previous/Next buttons.
Previous/Next buttons.
3. Preferences section headings are bold and 2 px larger than the text. 3. Preferences section headings are bold and 2 px larger than the text.
4. The laser page draws the rig, labelling distance, angles and dot size 4. The laser page draws the rig, labelling distance, angles and dot size
in place of those sliders' own numbers. in place of those sliders' own numbers.
@@ -15,62 +14,7 @@ from PyQt6.QtCore import QObject, pyqtSignal
from PyQt6.QtGui import QFontInfo from PyQt6.QtGui import QFontInfo
from PyQt6.QtWidgets import QApplication, QLabel, QPushButton from PyQt6.QtWidgets import QApplication, QLabel, QPushButton
from lintunes.player import volume_with_adjustment, VOLUME_ADJUSTMENT_MAX
from lintunes.preferences import Preferences from lintunes.preferences import Preferences
from tests.test_round29 import _player, _local_track, _FakeSink
# --------------------------------------------------------------------------
# 1. The player
# --------------------------------------------------------------------------
class TestVolumeAdjustment:
def test_none_changes_nothing(self):
assert volume_with_adjustment(0.6, 0) == 0.6
def test_minus_100_is_silence_and_plus_100_doubles(self):
assert volume_with_adjustment(0.6, -VOLUME_ADJUSTMENT_MAX) == 0.0
assert volume_with_adjustment(0.3, VOLUME_ADJUSTMENT_MAX) == 0.6
def test_never_past_full(self):
assert volume_with_adjustment(0.8, VOLUME_ADJUSTMENT_MAX) == 1.0
def test_out_of_range_values_are_clamped(self):
assert volume_with_adjustment(0.5, -10_000) == 0.0
assert volume_with_adjustment(0.5, 10_000) == 1.0
def test_applied_when_the_track_loads(self, qapp, tmp_path):
quiet = _local_track(tmp_path, 1, volume_adjustment=-128)
plain = _local_track(tmp_path, 2)
player = _player(qapp, [quiet, plain])
sink = _FakeSink()
player.set_sink(sink)
player.set_volume(0.8)
player.play_queue([1, 2], 0)
assert sink.volume == pytest.approx(0.8 * (1 - 128 / 255))
assert player.volume() == 0.8 # the slider is untouched
player.next()
assert sink.volume == pytest.approx(0.8)
def test_moving_the_slider_keeps_the_adjustment(self, qapp, tmp_path):
track = _local_track(tmp_path, 1, volume_adjustment=255)
player = _player(qapp, [track])
sink = _FakeSink()
player.set_sink(sink)
player.play_queue([1], 0)
player.set_volume(0.25)
assert sink.volume == pytest.approx(0.5)
def test_an_edit_while_playing_applies_on_refresh(self, qapp, tmp_path):
track = _local_track(tmp_path, 1)
player = _player(qapp, [track])
sink = _FakeSink()
player.set_sink(sink)
player.set_volume(0.6)
player.play_queue([1], 0)
track.volume_adjustment = -255
player.refresh_volume()
assert sink.volume == 0.0
# -------------------------------------------------------------------------- # --------------------------------------------------------------------------
@@ -99,48 +43,6 @@ class TestInfoDialog:
texts = {b.text() for b in _info(manager, ids).findChildren(QPushButton)} texts = {b.text() for b in _info(manager, ids).findChildren(QPushButton)}
assert not texts & {"Previous", "Next"} assert not texts & {"Previous", "Next"}
def test_shows_the_tracks_adjustment(self, qapp, manager):
dialog = _info(manager, [2])
assert dialog._volume.value() == 20 # 51/255
assert dialog._volume_label.text() == "+20%"
assert _info(manager, [1])._volume_label.text() == "None"
def test_saving_one_track(self, qapp, manager):
dialog = _info(manager, [1])
dialog._volume.setValue(-50)
dialog._on_ok()
assert manager.library.tracks[1].volume_adjustment == -128
def test_an_untouched_value_keeps_its_exact_number(self, qapp, manager):
manager.library.tracks[1].volume_adjustment = 37 # an iTunes value
dialog = _info(manager, [1])
dialog._on_ok()
assert manager.library.tracks[1].volume_adjustment == 37
def test_the_edit_is_undoable(self, qapp, manager):
dialog = _info(manager, [1])
dialog._volume.setValue(100)
dialog._on_ok()
manager.undo_stack.undo()
assert manager.library.tracks[1].volume_adjustment == 0
def test_several_tracks_mixed_untouched(self, qapp, manager):
dialog = _info(manager, [1, 2])
assert dialog._volume_label.text() == "Mixed"
dialog._on_ok()
assert manager.library.tracks[1].volume_adjustment == 0
assert manager.library.tracks[2].volume_adjustment == 51
def test_several_tracks_shared_value(self, qapp, manager):
assert _info(manager, [2, 3])._volume_label.text() == "+20%"
def test_several_tracks_touched(self, qapp, manager):
dialog = _info(manager, [1, 2])
dialog._volume.setValue(-100)
dialog._on_ok()
assert manager.library.tracks[1].volume_adjustment == -255
assert manager.library.tracks[2].volume_adjustment == -255
# -------------------------------------------------------------------------- # --------------------------------------------------------------------------
# 3 & 4. Preferences # 3 & 4. Preferences