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:
@@ -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,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"
|
||||||
|
|||||||
@@ -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
@@ -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
@@ -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
|
||||||
|
|||||||
@@ -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:
|
||||||
|
|||||||
@@ -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)))
|
||||||
try:
|
if not in_place:
|
||||||
trash.send_to_trash(new_path)
|
try:
|
||||||
except trash.TrashError:
|
trash.send_to_trash(new_path)
|
||||||
pass
|
except trash.TrashError:
|
||||||
|
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
@@ -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 ----
|
||||||
|
|
||||||
|
|||||||
@@ -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
@@ -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
|
||||||
|
|||||||
Reference in New Issue
Block a user