Files
lintunes/tests/test_round131.py
T

341 lines
13 KiB
Python

"""Round 131: Boost Volume (lintunes/boost.py) replaces the per-track Volume
Adjustment, which could never play past full volume.
It raises an MP3's own global_gain (mp3gain's method): nothing is re-encoded,
the decoded audio is the original times exactly 2^(steps/4), and it never
clips. Only MP3s get the button, in Get Info.
"""
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
"""
# ---- measuring and the plan ----
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_whole_steps_toward_typical(self):
p = boost.plan(-28.7, -18.9, -14.0) # wants 14.7, room 17.9
assert p.steps == 9 and p.gain_db == 13.5 and p.reaches_typical
def test_never_past_the_ceiling(self):
p = boost.plan(-28.7, -18.9, -10.0) # wants 18.7, room 17.9
assert p.steps == 11 and p.gain_db <= 17.9 and not p.reaches_typical
def test_nothing_to_do(self):
assert boost.plan(-9.0, -0.2, -10.0).steps == 0
assert boost.plan(-20.0, -0.5, -10.0).steps == 0 # no room
assert not boost.plan(None, None, -10.0).measurable
# ---- the MP3 gain ----
def _decode(path):
import numpy as np
out = subprocess.run(["ffmpeg", "-v", "error", "-i", str(path), "-f",
"f32le", "-ac", "1", "-"], capture_output=True).stdout
return np.frombuffer(out, np.float32)
@pytest.mark.parametrize("args", [
["-ac", "2", "-b:a", "192k"], # MPEG-1 stereo
["-ac", "1", "-b:a", "96k"], # MPEG-1 mono
["-ac", "2", "-ar", "22050", "-b:a", "64k"], # MPEG-2
["-ac", "1", "-ar", "11025", "-b:a", "32k"], # MPEG-2.5
])
def test_gain_is_exact_and_nothing_else_changes(tmp_path, args):
import numpy as np
if shutil.which("ffmpeg") is None:
pytest.skip("ffmpeg not available")
src = tmp_path / "in.mp3"
subprocess.run(["ffmpeg", "-y", "-f", "lavfi", "-i", "anoisesrc=d=2:a=0.05",
*args, "-c:a", "libmp3lame", str(src)],
capture_output=True, check=True)
assert boost.supported(str(src))
before = src.read_bytes()
dest = tmp_path / "out.mp3"
boost.boost_file(src, dest, 4) # +6 dB = exactly x2
assert src.read_bytes() == before # only read
after = dest.read_bytes()
assert len(after) == len(before)
a, b = _decode(src), _decode(dest)
assert len(a) == len(b)
assert np.max(np.abs(b - 2 * a)) < 1e-5
# Undoing the steps gives the original bytes back.
assert boost.apply_gain(after, -4) == before
def test_silent_granules_are_left_alone():
"""LAME parks silence at 210/255; those must not count against the
ceiling, or a quiet song with a silent intro could never be boosted."""
data = bytearray(_frame_stream(gain=150, frames=20))
# Make frame 3's first granule silent at gain 255.
frame = next(f for i, f in enumerate(boost._frames(data)) if i == 3)
bit = next(boost._gain_bits(frame))
boost._set8(data, frame.side_offset, bit, 255)
_set_bits(data, frame.side_offset, bit - 21, 12, 0)
assert boost.headroom_steps(bytes(data)) == 255 - 150
boosted = boost.apply_gain(bytes(data), 10)
assert boost._get8(boosted, frame.side_offset, bit) == 255
def test_what_isnt_supported(tmp_path):
flac = tmp_path / "a.flac"
flac.write_bytes(b"fLaC" + bytes(100))
assert not boost.supported(str(flac))
crc = tmp_path / "crc.mp3"
crc.write_bytes(_frame_stream(gain=150, frames=20, crc=True))
assert not boost.supported(str(crc))
junk = tmp_path / "junk.mp3"
junk.write_bytes(bytes(5000))
assert not boost.supported(str(junk))
with pytest.raises(boost.Mp3Error):
boost.apply_gain(bytes(5000), 2)
def _set_bits(buf, base, bit, count, value):
for i in range(count):
b = bit + i
mask = 1 << (7 - b % 8)
if (value >> (count - 1 - i)) & 1:
buf[base + b // 8] |= mask
else:
buf[base + b // 8] &= ~mask & 0xFF
def _frame_stream(gain: int, frames: int, crc: bool = False) -> bytes:
"""Hand-made MPEG-1 Layer III stereo frames, 128 kbps 44.1 kHz, each
granule with some audio data and ``gain``."""
header = bytes([0xFF, 0xFA if crc else 0xFB, 0x90, 0x00])
out = bytearray()
for _ in range(frames):
frame = bytearray(header) + bytearray(417 - 4)
f = boost._header(frame + header, 0)
for bit in boost._gain_bits(f):
_set_bits(frame, f.side_offset, bit - 21, 12, 100)
boost._set8(frame, f.side_offset, bit, gain)
out += frame
return bytes(out)
# ---- 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.boost_file(Path(location), staged, 6)
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] + 8
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_offers_it_only_for_mp3s(qapp, tmp_path):
from PyQt6.QtWidgets import QPushButton, QSlider
from lintunes.gui.info_dialog import InfoDialog
mp3 = _quiet_mp3(tmp_path / "a.mp3")
flac = tmp_path / "b.flac"
flac.write_bytes(b"fLaC" + bytes(100))
library = Library()
library.tracks[1] = Track(track_id=1, name="A", location=str(mp3))
library.tracks[2] = Track(track_id=2, name="B", location=str(flac))
manager = LibraryManager(library, tmp_path / "data")
def button(dialog):
return next(b for b in dialog.findChildren(QPushButton)
if b.text() == "Boost Volume…")
for ids, shown in (([1], True), ([2], False), ([1, 2], True)):
dialog = InfoDialog(manager, ids)
assert not dialog.findChildren(QSlider)
assert dialog._form.isRowVisible(dialog._boost_row) == shown
if shown:
asked = []
dialog.boost_requested.connect(asked.append)
button(dialog).click()
assert asked == [[1]] # only the MP3
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.steps 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].steps > 0
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()