v0.64.0: DJ mode round two — vocals models, Prepare for DJ, deck volumes, ½×/2×, scrubbing, air horn

- Preferences › DJ: vocals model (Best / Balanced / Fast) and gentle CPU
  use (a quarter of the cores, lowest priority — measured only ~20%
  slower). Splits are cached per model; a deck uses the best one.
- Prepare for DJ on a playlist or songs: BPM and vocals ahead of time.
- Each deck: a volume fader on the outer edge, labelled beside Tempo; a
  ½×/1×/2× switch for half/double-time counting.
- Drag a waveform to scrub (backwards too).
- Crossfader: a handle twice as tall, a middle line, a snap to centre;
  narrower. "calculated, saved" is gone from the BPM line.
- Keep pitch shows a checkmark. An air horn to hold.
- The visualizer draws the mix; the sidebar art hides in DJ mode.
- The Library button has the transport buttons' 8 px corners.
This commit is contained in:
2026-10-17 03:13:59 -07:00
parent 8298450814
commit 6d6a0c2385
16 changed files with 1029 additions and 97 deletions
+19
View File
@@ -387,6 +387,25 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
(`stems.setup_command()`; it needs numpy installed explicitly), never a (`stems.setup_command()`; it needs numpy installed explicitly), never a
pip dependency of LinTunes — without it the slider is disabled with that pip dependency of LinTunes — without it the slider is disabled with that
command in its tooltip. command in its tooltip.
**Round 94**: Demucs is the CPU hog (htdemucs: 29 s per 40 s of audio on
8 cores, 35 s on 2 — so cores barely matter), so it always runs niced
and Preferences › DJ (its own page) picks the model (`stems.MODELS`:
Best = htdemucs_ft, Balanced = htdemucs, Fast = htdemucs at overlap 0.1,
~25 % quicker; hdemucs_mmi 42 s and mdx 156 s were slower, no "fast"
model exists) and "gentle" (default: a quarter of the cores, nice 19).
Splits are cached per model (`<key>/<model>/`; Round 93's sit in
`<key>/` and count as htdemucs) and a deck takes the best one cached.
**Prepare for DJ** (a playlist's or songs' right-click; `dj/prepare.py`)
does the BPM + split ahead of time with the status-bar progress/cancel.
Each deck also has a volume fader (outer edge, perceptual), a ½×/1×/2×
switch (half/double-time: the BPM shown, the beat ticks and what Sync
matches — `analysis.sync_speed` takes the straight ratio unless it's
implausible, then the nearest octave), and its waveform lane scrubs when
dragged (a scratch at the drag's rate). The crossfader is
`dj_shelf.Crossfader` (big handle, a middle line, snaps within 3 %). An
air-horn button (held = longer; `audio.Horn`, synthesised). The
transport's visualizer draws the mix in DJ mode (`Mixer.tap` →
`VisualizerWidget.set_dj_source/feed_dj`). The sidebar art hides.
- **`lintunes/importers/itunes_importer.py`** — parses the iTunes XML plist. - **`lintunes/importers/itunes_importer.py`** — parses the iTunes XML plist.
Remaps Mac `file:///Volumes/...` paths to the local `--music-root` with Remaps Mac `file:///Volumes/...` paths to the local `--music-root` with
+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.63.1" __version__ = "0.64.0"
+14
View File
@@ -137,6 +137,20 @@ def sync_ratio(own_bpm: float, target_bpm: float) -> float:
return min((ratio, ratio * 2, ratio / 2), key=lambda r: abs(np.log2(r))) return min((ratio, ratio * 2, ratio / 2), key=lambda r: abs(np.log2(r)))
def sync_speed(own_beat_bpm: float, target_beat_bpm: float,
plausible: tuple[float, float] = (0.75, 1.34)) -> float:
"""The speed that plays ``own`` at ``target``, both as the decks count
their beats (the ½×/1×/2× switch already applied). Taken straight when
it's a plausible change of speed; a ratio further out than that means
the two are counted an octave apart, so the nearest octave wins."""
if not own_beat_bpm or not target_beat_bpm:
return 1.0
ratio = target_beat_bpm / own_beat_bpm
if plausible[0] <= ratio <= plausible[1]:
return ratio
return sync_ratio(own_beat_bpm, target_beat_bpm)
def beat_phase(position_s: float, offset_s: float, bpm: float) -> float: def beat_phase(position_s: float, offset_s: float, bpm: float) -> float:
"""Where in its beat a song is, 0..1.""" """Where in its beat a song is, 0..1."""
if not bpm: if not bpm:
+52 -3
View File
@@ -18,6 +18,8 @@ master volume, and clips. Everything here runs on the sink's thread; the GUI
only sets plain attributes (one assignment each, so never torn). only sets plain attributes (one assignment each, so never torn).
""" """
from collections import deque
import numpy as np import numpy as np
RATE = 44100 RATE = 44100
@@ -86,6 +88,7 @@ class Deck:
self.keep_pitch = True self.keep_pitch = True
self.vocal_mix = 0.0 self.vocal_mix = 0.0
self.scratch_rate: float | None = None self.scratch_rate: float | None = None
self.volume = 1.0 # the deck's own fader, before the crossfader
self.ended = False # reached the end by playing (GUI clears) self.ended = False # reached the end by playing (GUI clears)
self._ola: np.ndarray | None = None # overlap-add tail self._ola: np.ndarray | None = None # overlap-add tail
self._last: int | None = None # where the last window was read self._last: int | None = None # where the last window was read
@@ -227,20 +230,66 @@ def crossfade_gains(x: float) -> tuple[float, float]:
return float(np.cos(x * np.pi / 2)), float(np.sin(x * np.pi / 2)) return float(np.cos(x * np.pi / 2)), float(np.sin(x * np.pi / 2))
class Horn:
"""The rap air horn, synthesised: three detuned, brassy sawtooths a
rough major chord apart, through a soft clip, blaring for as long as
``on`` is held (15 ms attack, 120 ms tail when let go)."""
FREQS = (369.99, 466.16, 554.37) # F#4, A#4, C#5
ATTACK, RELEASE = 0.015, 0.12
LEVEL = 0.32
def __init__(self):
self.on = False
self._phase = np.zeros(len(self.FREQS))
self._env = 0.0
def render(self, count: int) -> np.ndarray | None:
if not self.on and self._env <= 1e-4:
self._env = 0.0
return None
t = np.arange(count) / RATE
target = 1.0 if self.on else 0.0
step = 1.0 / ((self.ATTACK if self.on else self.RELEASE) * RATE)
env = np.clip(self._env + (step if self.on else -step) * np.arange(1, count + 1),
0.0, 1.0) if target != self._env else np.full(count, self._env)
self._env = float(env[-1])
wave = np.zeros(count)
for i, f in enumerate(self.FREQS):
for detune in (0.997, 1.0, 1.004):
phase = (self._phase[i] * detune + f * detune * t) % 1.0
wave += 2.0 * phase - 1.0
self._phase[i] = (self._phase[i] + f * count / RATE) % 1.0
# a little flutter, like air through a reed
wave *= 1.0 + 0.08 * np.sin(2 * np.pi * 7.0 * t)
sound = np.tanh(wave / 3.0 * 1.8) * self.LEVEL * env
return np.repeat(sound[:, None].astype(np.float32), CHANNELS, axis=1)
class Mixer: class Mixer:
def __init__(self): def __init__(self):
self.a = Deck("A") self.a = Deck("A")
self.b = Deck("B") self.b = Deck("B")
self.crossfader = 0.5 self.crossfader = 0.5
self.master = 1.0 self.master = 1.0
self.horn = Horn()
# What was rendered, for the visualizer: (first frame, mono) blocks,
# appended here (the sink's thread), drained by the GUI.
self.tap = deque(maxlen=128)
self.rendered = 0
def deck_gain(self, deck: Deck) -> float: def deck_gain(self, deck: Deck) -> float:
a, b = crossfade_gains(self.crossfader) a, b = crossfade_gains(self.crossfader)
return (a if deck is self.a else b) * self.master return (a if deck is self.a else b) * deck.volume * self.master
def render(self, count: int) -> np.ndarray: def render(self, count: int) -> np.ndarray:
ga, gb = crossfade_gains(self.crossfader) ga, gb = crossfade_gains(self.crossfader)
out = self.a.render(count) * (ga * self.master) out = self.a.render(count) * (ga * self.a.volume * self.master)
out += self.b.render(count) * (gb * self.master) out += self.b.render(count) * (gb * self.b.volume * self.master)
horn = self.horn.render(count)
if horn is not None:
out += horn * self.master
np.clip(out, -1.0, 1.0, out=out) np.clip(out, -1.0, 1.0, out=out)
self.tap.append((self.rendered, out.mean(axis=1)))
self.rendered += count
return out return out
+72
View File
@@ -0,0 +1,72 @@
"""Prepare for DJ: the slow part of a deck load, done ahead for many songs.
For each song: its BPM, worked out and saved to the file when it has none
(the GUI applies it, as Calculate BPM does), and its vocals/instrumental
split with the vocals model set in Preferences › DJ — so a whole playlist
can be split with the slow, best model overnight and every deck load after
that is instant. One song at a time on a daemon thread, ExportWorker's
shape: ``progress``, ``bpm_found``, ``finished``; ``cancel`` stops between
songs and kills a split in progress.
"""
import threading
from PyQt6.QtCore import QObject, pyqtSignal
from lintunes import bpm_detect
from lintunes.dj import stems
class DjPrepWorker(QObject):
progress = pyqtSignal(int, int, str) # done, total, what's happening
bpm_found = pyqtSignal(int, int) # track id, bpm
finished = pyqtSignal(dict) # {"done", "split", "bpm", "failed", "cancelled"}
def __init__(self, items, model: str, gentle: bool, parent=None):
"""``items``: (track id, path, label, has bpm)."""
super().__init__(parent)
self._items = list(items)
self._model = model
self._gentle = gentle
self._cancel = threading.Event()
self._thread = None
def busy(self) -> bool:
return self._thread is not None and self._thread.is_alive()
def cancel(self):
self._cancel.set()
def start(self):
self._thread = threading.Thread(target=self._run, daemon=True,
name="lintunes-dj-prepare")
self._thread.start()
def _run(self):
summary = {"done": 0, "split": 0, "bpm": 0, "failed": 0, "cancelled": False}
total = len(self._items)
for i, (track_id, path, label, has_bpm) in enumerate(self._items):
if self._cancel.is_set():
summary["cancelled"] = True
break
try:
if not has_bpm:
self.progress.emit(i, total, f"BPM · {label}")
bpm = bpm_detect.detect_file(path)
if bpm is not None:
self.bpm_found.emit(track_id, bpm)
summary["bpm"] += 1
if stems.available() and stems.cached(path, self._model) is None:
def tick(percent, i=i, label=label):
self.progress.emit(i, total, f"Vocals {percent}% · {label}")
self.progress.emit(i, total, f"Vocals · {label}")
stems.split(path, self._model, self._gentle, tick, self._cancel)
summary["split"] += 1
summary["done"] += 1
except stems.Cancelled:
summary["cancelled"] = True
break
except Exception: # noqa: BLE001 — counted, the batch goes on
summary["failed"] += 1
self.progress.emit(total, total, "")
self.finished.emit(summary)
+128 -59
View File
@@ -1,16 +1,21 @@
"""Vocals and instrumental, for the decks' vocals sliders: Demucs. """Vocals and instrumental, for the decks' vocals sliders: Demucs.
Nothing separates a voice from a mix in real time on a laptop, so a song is Nothing separates a voice from a mix in real time on a laptop, so a song is
split once, in the background, when it lands on a deck, and kept: split once, in the background, and kept:
``$XDG_CACHE_HOME/lintunes/stems/<key>/{vocals,no_vocals}.flac``, keyed by ``$XDG_CACHE_HOME/lintunes/stems/<key>/<model>/{vocals,no_vocals}.flac``,
path + size + mtime like the loudness cache (machine-local, never the keyed by path + size + mtime like the loudness cache (machine-local, never
synced data dir). A cached song's slider works the moment it loads. the synced data dir). A cached song's slider works the moment it loads, and
a deck uses the best split it finds whatever model made it. (Round 93's
first splits sit directly in ``<key>/``; they were htdemucs.)
Demucs (Meta's htdemucs model, two-stem mode) runs as a runtime tool, never a Demucs runs as a runtime tool, never a pip dependency of LinTunes: PyTorch is
pip dependency of LinTunes: PyTorch is ~1 GB, so it lives in its own venv at ~1 GB, so it lives in its own venv at ``$XDG_DATA_HOME/lintunes/demucs``
``$XDG_DATA_HOME/lintunes/demucs`` (``setup_command`` makes it), and (``setup_command`` makes it), and LinTunes runs ``<venv>/bin/python -m
LinTunes runs ``<venv>/bin/python -m demucs``. On CPU a song takes about demucs``. It is *the* CPU hog in LinTunes (Round 94: htdemucs took 29 s for
as long as it plays, give or take; progress is read off its tqdm bar. 40 s of audio on all 8 cores — several hot minutes a song), so it always
runs niced, and "gentle" (Preferences › DJ, the default) caps it at a
quarter of the cores: measured only ~20 % slower, far cooler. Which model is
a Preferences choice too (``MODELS``). Progress is read off its tqdm bar.
One split at a time: two would only halve each other's speed. One split at a time: two would only halve each other's speed.
""" """
@@ -25,11 +30,32 @@ from pathlib import Path
from PyQt6.QtCore import QObject, pyqtSignal from PyQt6.QtCore import QObject, pyqtSignal
MODEL = "htdemucs" # id → (label, what it costs). Best first: a deck uses the best split it has.
# Measured on this laptop (Round 94, 40 s of audio, 2 threads): htdemucs
# 35 s, at overlap 0.1 27 s; hdemucs_mmi 42 s and mdx 156 s were slower,
# so no other Demucs model is a "fast" one — fewer overlapping windows is.
MODELS = {
"htdemucs_ft": ("Best", "4 fine-tuned models: cleanest, about 4× slower"),
"htdemucs": ("Balanced", "about as long as the song plays"),
"htdemucs_fast": ("Fast", "the same model, fewer overlapping windows: "
"~25 % quicker, very slightly rougher"),
}
# id → the demucs command-line arguments that make it
_ARGS = {
"htdemucs_ft": ["-n", "htdemucs_ft"],
"htdemucs": ["-n", "htdemucs"],
"htdemucs_fast": ["-n", "htdemucs", "--overlap", "0.1"],
}
DEFAULT_MODEL = "htdemucs"
LEGACY_MODEL = "htdemucs" # Round 93's splits, made before models had folders
STEMS = ("vocals", "no_vocals") STEMS = ("vocals", "no_vocals")
_PERCENT = re.compile(r"(\d{1,3})%\|") _PERCENT = re.compile(r"(\d{1,3})%\|")
class Cancelled(Exception):
pass
def venv_dir() -> Path: def venv_dir() -> Path:
base = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share") base = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")
return Path(base) / "lintunes" / "demucs" return Path(base) / "lintunes" / "demucs"
@@ -50,6 +76,20 @@ def setup_command() -> str:
f"https://download.pytorch.org/whl/cpu && {v}/bin/pip install numpy demucs") f"https://download.pytorch.org/whl/cpu && {v}/bin/pip install numpy demucs")
def model_choice(prefs) -> str:
value = prefs.get("dj_stem_model", DEFAULT_MODEL) if prefs is not None else DEFAULT_MODEL
return value if value in MODELS else DEFAULT_MODEL
def gentle_choice(prefs) -> bool:
return bool(prefs.get("dj_stem_gentle", True)) if prefs is not None else True
def threads(gentle: bool) -> int:
cores = os.cpu_count() or 4
return max(1, cores // 4) if gentle else cores
def cache_root() -> Path: def cache_root() -> Path:
base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache") base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache")
return Path(base) / "lintunes" / "stems" return Path(base) / "lintunes" / "stems"
@@ -64,14 +104,26 @@ def cache_key(path: str) -> str | None:
return hashlib.sha1(raw.encode()).hexdigest()[:20] return hashlib.sha1(raw.encode()).hexdigest()[:20]
def cached(path: str) -> dict[str, Path] | None: def _files(folder: Path) -> dict[str, Path] | None:
"""{"vocals": …, "no_vocals": …} when this song was split already.""" files = {name: folder / f"{name}.flac" for name in STEMS}
return files if all(f.is_file() for f in files.values()) else None
def cached(path: str, model: str | None = None) -> dict[str, Path] | None:
"""The stems of ``path``: ``model``'s when given, else the best there
are (``MODELS`` order). None when it hasn't been split."""
key = cache_key(path) key = cache_key(path)
if key is None: if key is None:
return None return None
folder = cache_root() / key root = cache_root() / key
files = {name: folder / f"{name}.flac" for name in STEMS} order = [model] if model else list(MODELS)
return files if all(f.is_file() for f in files.values()) else None for name in order:
hit = _files(root / name)
if hit is None and name == LEGACY_MODEL:
hit = _files(root)
if hit is not None:
return hit
return None
def parse_progress(text: str) -> int | None: def parse_progress(text: str) -> int | None:
@@ -79,21 +131,76 @@ def parse_progress(text: str) -> int | None:
return int(found[-1]) if found else None return int(found[-1]) if found else None
def split(path: str, model: str, gentle: bool, progress=None,
cancel: threading.Event | None = None) -> dict[str, Path]:
"""Run Demucs on ``path`` (blocking) and cache the two stems. Raises
OSError on failure and Cancelled when ``cancel`` is set."""
if not available():
raise OSError("Demucs isn't set up on this computer")
key = cache_key(path)
if key is None:
raise OSError("the file is missing")
model = model if model in MODELS else DEFAULT_MODEL
work = Path(tempfile.mkdtemp(prefix="lintunes-stems-"))
count = str(threads(gentle))
env = dict(os.environ, OMP_NUM_THREADS=count, MKL_NUM_THREADS=count)
niceness = 19 if gentle else 10
try:
cmd = ([str(python()), "-m", "demucs", "--two-stems=vocals"] + _ARGS[model]
+ ["--flac", "-o", str(work), path])
process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
env=env, preexec_fn=lambda: os.nice(niceness))
tail = b""
last = -1
while True:
if cancel is not None and cancel.is_set():
process.kill()
process.wait()
raise Cancelled()
chunk = process.stderr.read(256)
if not chunk:
break
tail = (tail + chunk)[-4096:]
percent = parse_progress(tail.decode(errors="replace"))
if percent is not None and percent != last and progress is not None:
last = percent
progress(percent)
if process.wait() != 0:
lines = tail.decode(errors="replace").strip().splitlines()
raise OSError(lines[-1] if lines else "Demucs failed")
made = list(work.rglob("vocals.flac"))
if not made:
raise OSError("Demucs wrote nothing")
folder = cache_root() / key / model
folder.mkdir(parents=True, exist_ok=True)
out = {}
for name in STEMS:
target = folder / f"{name}.flac"
shutil.move(str(made[0].parent / f"{name}.flac"), target)
out[name] = target
return out
finally:
shutil.rmtree(work, ignore_errors=True)
class StemSplitter(QObject): class StemSplitter(QObject):
"""A queue of songs to split, one Demucs run at a time.""" """A queue of songs to split for the decks, one Demucs run at a time.
``settings`` returns (model, gentle) when each split starts, so a change
in Preferences applies to the next song."""
progress = pyqtSignal(str, int) # path, percent progress = pyqtSignal(str, int) # path, percent
finished = pyqtSignal(str, object) # path, {"vocals": Path, …} finished = pyqtSignal(str, object) # path, {"vocals": Path, …}
failed = pyqtSignal(str, str) # path, why failed = pyqtSignal(str, str) # path, why
def __init__(self, parent=None): def __init__(self, settings=None, parent=None):
super().__init__(parent) super().__init__(parent)
self._settings = settings or (lambda: (DEFAULT_MODEL, True))
self._queue: list[str] = [] self._queue: list[str] = []
self._busy = False self._busy = False
self._lock = threading.Lock() self._lock = threading.Lock()
def request(self, path: str): def request(self, path: str):
"""Split ``path`` unless it's cached (then report it at once).""" """Split ``path`` unless any split of it is cached (then report it)."""
hit = cached(path) hit = cached(path)
if hit is not None: if hit is not None:
self.finished.emit(path, hit) self.finished.emit(path, hit)
@@ -115,49 +222,11 @@ class StemSplitter(QObject):
self._busy = False self._busy = False
return return
path = self._queue.pop(0) path = self._queue.pop(0)
model, gentle = self._settings()
try: try:
result = self._split(path) result = split(path, model, gentle,
lambda percent, path=path: self.progress.emit(path, percent))
except Exception as e: # noqa: BLE001 — reported, never raised except Exception as e: # noqa: BLE001 — reported, never raised
self.failed.emit(path, str(e) or type(e).__name__) self.failed.emit(path, str(e) or type(e).__name__)
continue continue
self.finished.emit(path, result) self.finished.emit(path, result)
def _split(self, path: str) -> dict[str, Path]:
if not available():
raise OSError("Demucs isn't set up on this computer")
key = cache_key(path)
if key is None:
raise OSError("the file is missing")
work = Path(tempfile.mkdtemp(prefix="lintunes-stems-"))
try:
cmd = [str(python()), "-m", "demucs", "--two-stems=vocals", "-n", MODEL,
"--flac", "-o", str(work), path]
process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE)
tail = b""
last = -1
while True:
chunk = process.stderr.read(256)
if not chunk:
break
tail = (tail + chunk)[-4096:]
percent = parse_progress(tail.decode(errors="replace"))
if percent is not None and percent != last:
last = percent
self.progress.emit(path, percent)
if process.wait() != 0:
lines = tail.decode(errors="replace").strip().splitlines()
raise OSError(lines[-1] if lines else "Demucs failed")
made = list(work.rglob("vocals.flac"))
if not made:
raise OSError("Demucs wrote nothing")
folder = cache_root() / key
folder.mkdir(parents=True, exist_ok=True)
out = {}
for name in STEMS:
target = folder / f"{name}.flac"
shutil.move(str(made[0].parent / f"{name}.flac"), target)
out[name] = target
return out
finally:
shutil.rmtree(work, ignore_errors=True)
+377 -25
View File
@@ -66,11 +66,18 @@ class DeckView:
self.stem_note = "" self.stem_note = ""
self.bpm_saved = False self.bpm_saved = False
self.counted = False self.counted = False
self.mult = 1.0 # the ½× / 1× / 2× switch
@property @property
def color(self) -> QColor: def color(self) -> QColor:
return COLORS[self.name] return COLORS[self.name]
@property
def beat_bpm(self) -> float | None:
"""The tempo the beats are counted at: the song's, halved or doubled
by the switch (half-time / double-time)."""
return self.bpm * self.mult if self.bpm else None
# ---- small painted pieces ---- # ---- small painted pieces ----
@@ -95,6 +102,32 @@ def _play_icon(playing: bool, size=16) -> QPixmap:
return pix return pix
_CHECK_SVG = None
def _check_svg() -> str:
"""A white checkmark for checked boxes, written once to the cache (a
style sheet's ``image:`` takes a file, not data)."""
global _CHECK_SVG
if _CHECK_SVG is None:
import os
import tempfile
base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache")
folder = os.path.join(base, "lintunes")
try:
os.makedirs(folder, exist_ok=True)
except OSError:
folder = tempfile.gettempdir()
path = os.path.join(folder, "dj-check.svg")
with open(path, "w") as out:
out.write('<svg xmlns="http://www.w3.org/2000/svg" width="13" height="13" '
'viewBox="0 0 13 13"><path d="M2.5 6.8 L5.3 9.6 L10.6 3.6" '
'fill="none" stroke="white" stroke-width="2" '
'stroke-linecap="round" stroke-linejoin="round"/></svg>')
_CHECK_SVG = path.replace("\\", "/")
return _CHECK_SVG
def _deck_button_qss(name: str) -> str: def _deck_button_qss(name: str) -> str:
top, bottom = FACES[name] top, bottom = FACES[name]
color = COLORS[name].name() color = COLORS[name].name()
@@ -109,7 +142,8 @@ def _deck_button_qss(name: str) -> str:
f"QCheckBox {{ color: {TEXT}; }}" f"QCheckBox {{ color: {TEXT}; }}"
f"QCheckBox::indicator {{ width: 13px; height: 13px; border: 1px solid #111;" f"QCheckBox::indicator {{ width: 13px; height: 13px; border: 1px solid #111;"
f" border-radius: 3px; background: #1b1b1c; }}" f" border-radius: 3px; background: #1b1b1c; }}"
f"QCheckBox::indicator:checked {{ background: {color}; }}") f"QCheckBox::indicator:checked {{ background: {color};"
f" image: url({_check_svg()}); }}")
def _slider_qss(name: str | None, vertical: bool) -> str: def _slider_qss(name: str | None, vertical: bool) -> str:
@@ -333,6 +367,61 @@ class WaveLanes(QWidget):
self.shelf = shelf self.shelf = shelf
self.setMinimumHeight(40) self.setMinimumHeight(40)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding) self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
self.setToolTip("Drag a waveform to move through its song — "
"it plays what passes the playhead, backwards too")
self._drag = None # (view, x, time)
self._rate = 0.0
self._still = QTimer(self)
self._still.setInterval(45)
self._still.timeout.connect(self._hand_still)
# Dragging a lane is a scratch along the waveform: the playhead plays
# whatever passes under it, at the speed (and direction) it passes.
def _view_at(self, y: float):
views = self.shelf.views
return views[0] if y < self.height() / 2 else views[1]
def mousePressEvent(self, event):
if event.button() != Qt.MouseButton.LeftButton:
return super().mousePressEvent(event)
view = self._view_at(event.position().y())
if view.deck.source is None:
return
self._drag = (view, event.position().x(), time.monotonic())
self._rate = 0.0
view.deck.scratch_rate = 0.0
self.setCursor(Qt.CursorShape.ClosedHandCursor)
self._still.start()
def mouseMoveEvent(self, event):
if self._drag is None:
return
view, x0, t0 = self._drag
now = time.monotonic()
dx = event.position().x() - x0
dt = max(1e-3, now - t0)
# dragging right pulls the song back under the playhead
seconds = -dx / max(1, self.width()) * WINDOW_SECONDS * view.deck.speed
rate = seconds / dt
self._rate = 0.6 * rate + 0.4 * self._rate
view.deck.scratch_rate = max(-8.0, min(8.0, self._rate))
self._drag = (view, event.position().x(), now)
self._still.start()
def _hand_still(self):
if self._drag is not None:
self._rate = 0.0
self._drag[0].deck.scratch_rate = 0.0
def mouseReleaseEvent(self, event):
if self._drag is None:
return super().mouseReleaseEvent(event)
self._still.stop()
view = self._drag[0]
self._drag = None
view.deck.scratch_rate = None
self.unsetCursor()
def paintEvent(self, event): def paintEvent(self, event):
p = QPainter(self) p = QPainter(self)
@@ -383,8 +472,8 @@ class WaveLanes(QWidget):
p.setPen(QPen(color, 1)) p.setPen(QPen(color, 1))
for x, a, b in lines: for x, a, b in lines:
p.drawLine(QPointF(x + 0.5, a), QPointF(x + 0.5, b)) p.drawLine(QPointF(x + 0.5, a), QPointF(x + 0.5, b))
if view.bpm: if view.beat_bpm:
beat = 60.0 / view.bpm beat = 60.0 / view.beat_bpm
first = math.ceil((edges[0] - view.offset) / beat) first = math.ceil((edges[0] - view.offset) / beat)
last = math.floor((edges[-1] - view.offset) / beat) last = math.floor((edges[-1] - view.offset) / beat)
p.setPen(QPen(QColor("#e8e8e8"), 1)) p.setPen(QPen(QColor("#e8e8e8"), 1))
@@ -398,6 +487,133 @@ class WaveLanes(QWidget):
p.drawLine(QPointF(x, lane.bottom() - 6), QPointF(x, lane.bottom() - 1)) p.drawLine(QPointF(x, lane.bottom() - 6), QPointF(x, lane.bottom() - 1))
class HornButton(QToolButton):
"""The air horn: it blares for as long as it's held."""
def __init__(self, horn, parent=None):
super().__init__(parent)
self._horn = horn
self.setToolTip("Air horn — hold for a longer blast")
self.setFixedSize(44, 28)
self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setIcon(QIcon(_horn_icon()))
self.setIconSize(QSize(26, 18))
self.setStyleSheet(
"QToolButton { border: 1px solid #111; border-radius: 6px;"
" background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 #5a5c5f, stop:1 #3d3f42); }"
"QToolButton:hover { background: #4a4c4f; }"
"QToolButton:pressed { background: #2a2b2d; }")
self.pressed.connect(lambda: setattr(self._horn, "on", True))
self.released.connect(lambda: setattr(self._horn, "on", False))
def _horn_icon(w=26, h=18) -> QPixmap:
"""A little air horn: a canister and a flared bell."""
pix = QPixmap(w, h)
pix.fill(Qt.GlobalColor.transparent)
p = QPainter(pix)
p.setRenderHint(QPainter.RenderHint.Antialiasing)
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(QColor("#f0f0f0"))
p.drawRoundedRect(QRectF(1, 6, 7, 10), 2, 2) # the can
p.drawRect(QRectF(3, 3.5, 3, 2.5)) # its button
horn = QPainterPath(QPointF(8, 9.5)) # a thin neck…
horn.lineTo(15, 9.5)
horn.cubicTo(QPointF(19, 9), QPointF(22, 5), QPointF(25, 2.5)) # …flaring out
horn.lineTo(25, 15.5)
horn.cubicTo(QPointF(22, 13), QPointF(19, 11.5), QPointF(15, 11.5))
horn.lineTo(8, 11.5)
horn.closeSubpath()
p.drawPath(horn)
p.end()
return pix
class Crossfader(QWidget):
"""The crossfader: a big handle on a slim track, a line at the middle,
and a gentle snap to the middle when the handle is let go close to it.
0..1000, like a QSlider's value; double-click centres it."""
valueChanged = pyqtSignal(int)
SNAP = 30 # within 3 % of the middle → the middle
HANDLE = QSize(28, 44)
TRACK = 8
def __init__(self, parent=None):
super().__init__(parent)
self._value = 500
self._dragging = False
self.setFixedHeight(self.HANDLE.height() + 4)
self.setMinimumWidth(160)
self.setToolTip("Crossfader (double-click: centre)")
def value(self) -> int:
return self._value
def setValue(self, value: int):
value = max(0, min(1000, int(value)))
if value != self._value:
self._value = value
self.valueChanged.emit(value)
self.update()
def _span(self) -> tuple[float, float]:
half = self.HANDLE.width() / 2
return half, self.width() - half
def _value_at(self, x: float) -> int:
lo, hi = self._span()
return round((x - lo) / max(1.0, hi - lo) * 1000)
def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton:
self._dragging = True
self.setValue(self._value_at(event.position().x()))
def mouseMoveEvent(self, event):
if self._dragging:
value = self._value_at(event.position().x())
if abs(value - 500) <= self.SNAP:
value = 500 # a little detent at the middle
self.setValue(value)
def mouseReleaseEvent(self, event):
self._dragging = False
if abs(self._value - 500) <= self.SNAP:
self.setValue(500)
def mouseDoubleClickEvent(self, event):
self.setValue(500)
def paintEvent(self, event):
p = QPainter(self)
p.setRenderHint(QPainter.RenderHint.Antialiasing)
lo, hi = self._span()
mid_y = self.height() / 2
track = QRectF(lo - 4, mid_y - self.TRACK / 2, hi - lo + 8, self.TRACK)
path = QPainterPath()
path.addRoundedRect(track, self.TRACK / 2, self.TRACK / 2)
p.fillPath(path, QColor("#1b1b1c"))
# the middle
cx = (lo + hi) / 2
p.setPen(QPen(QColor("#8a8a8a"), 2))
p.drawLine(QPointF(cx, 2), QPointF(cx, self.height() - 2))
x = lo + (hi - lo) * self._value / 1000
handle = QRectF(x - self.HANDLE.width() / 2, mid_y - self.HANDLE.height() / 2,
self.HANDLE.width(), self.HANDLE.height())
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(QColor(0, 0, 0, 110))
p.drawRoundedRect(handle.translated(0, 2), 5, 5)
face = QLinearGradient(handle.topLeft(), handle.bottomLeft())
face.setColorAt(0, QColor("#f2f2f2"))
face.setColorAt(1, QColor("#b2b2b2"))
p.setBrush(QBrush(face))
p.setPen(QPen(QColor("#111"), 1))
p.drawRoundedRect(handle, 5, 5)
p.setPen(QPen(QColor("#555"), 2))
p.drawLine(QPointF(x, handle.top() + 8), QPointF(x, handle.bottom() - 8))
class Grip(QWidget): class Grip(QWidget):
"""The shelf's bottom edge: drag to resize, double-click for the default.""" """The shelf's bottom edge: drag to resize, double-click for the default."""
@@ -435,6 +651,24 @@ class Grip(QWidget):
self.reset.emit() self.reset.emit()
class DjVisualSource:
"""What the transport's visualizer reads in DJ mode: the mix's heard
position and whether anything is sounding (the player's two methods)."""
def __init__(self, shelf):
self.shelf = shelf
def position_ms(self) -> float:
out = self.shelf._output
latency = out.latency_frames if out is not None else 0
return (self.shelf.mixer.rendered - latency) * 1000.0 / RATE
def is_playing(self) -> bool:
m = self.shelf.mixer
return (m.a.playing or m.b.playing or m.a.scratch_rate is not None
or m.b.scratch_rate is not None or m.horn.on)
# ---- the shelf ---- # ---- the shelf ----
class DjShelf(QWidget): class DjShelf(QWidget):
@@ -446,9 +680,10 @@ class DjShelf(QWidget):
_stems_ready = pyqtSignal(str, object) # path, (vocals, instrumental) _stems_ready = pyqtSignal(str, object) # path, (vocals, instrumental)
_stems_error = pyqtSignal(str, str) _stems_error = pyqtSignal(str, str)
def __init__(self, manager, parent=None): def __init__(self, manager, prefs=None, parent=None):
super().__init__(parent) super().__init__(parent)
self._manager = manager self._manager = manager
self._prefs = prefs
self.mixer = Mixer() self.mixer = Mixer()
self.views = [DeckView("A", self.mixer.a), DeckView("B", self.mixer.b)] self.views = [DeckView("A", self.mixer.a), DeckView("B", self.mixer.b)]
self._output = None self._output = None
@@ -460,7 +695,8 @@ class DjShelf(QWidget):
loader.failed.connect(self._on_loader_failed) loader.failed.connect(self._on_loader_failed)
self._stems_ready.connect(self._apply_stems) self._stems_ready.connect(self._apply_stems)
self._stems_error.connect(self._on_stem_failed) self._stems_error.connect(self._on_stem_failed)
self._splitter = stems.StemSplitter(self) self._splitter = stems.StemSplitter(
lambda: (stems.model_choice(self._prefs), stems.gentle_choice(self._prefs)), self)
self._splitter.progress.connect(self._on_stem_progress) self._splitter.progress.connect(self._on_stem_progress)
self._splitter.finished.connect(self._on_stems) self._splitter.finished.connect(self._on_stems)
self._splitter.failed.connect(self._on_stem_failed) self._splitter.failed.connect(self._on_stem_failed)
@@ -470,6 +706,9 @@ class DjShelf(QWidget):
self._timer = QTimer(self) self._timer = QTimer(self)
self._timer.setInterval(16) self._timer.setInterval(16)
self._timer.timeout.connect(self._tick) self._timer.timeout.connect(self._tick)
self.visual = DjVisualSource(self)
self._visualizer = None
self._sounding = False
# ---- layout ---- # ---- layout ----
@@ -487,6 +726,7 @@ class DjShelf(QWidget):
outer.addWidget(grip) outer.addWidget(grip)
self.speed = {} self.speed = {}
self.volume = {}
self.speed_label = {} self.speed_label = {}
self.records = {} self.records = {}
self.play_buttons = {} self.play_buttons = {}
@@ -498,12 +738,52 @@ class DjShelf(QWidget):
self.bpm_labels = {} self.bpm_labels = {}
self.bpm_notes = {} self.bpm_notes = {}
self.pitch_boxes = {} self.pitch_boxes = {}
self.mult_buttons = {}
self._compact_hidden = [] self._compact_hidden = []
self._big_records = {} self._big_records = {}
def fader_title(text, v):
label = QLabel(text)
label.setStyleSheet(f"color: {v.color.name()}; font-size: 10px;"
" font-weight: bold; letter-spacing: 1px;")
return label
def volume_col(v):
col = QVBoxLayout()
col.setSpacing(4)
slider = QSlider(Qt.Orientation.Vertical)
slider.setRange(0, 100)
slider.setValue(100)
slider.setStyleSheet(_slider_qss(v.name, vertical=True))
slider.setToolTip(f"Deck {v.name} volume (double-click: full)")
slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
slider.mouseDoubleClickEvent = lambda e, s=slider: s.setValue(100)
label = QLabel("100%")
label.setStyleSheet(f"color: {v.color.name()}; font-size: 11px;")
label.setAlignment(Qt.AlignmentFlag.AlignCenter)
def changed(value, v=v, label=label):
# a fader's travel is perceptual, like the main volume slider
from PyQt6.QtMultimedia import QAudio
v.deck.volume = QAudio.convertVolume(
value / 100, QAudio.VolumeScale.LogarithmicVolumeScale,
QAudio.VolumeScale.LinearVolumeScale)
label.setText(f"{value}%")
slider.valueChanged.connect(changed)
col.addWidget(fader_title("VOLUME", v), alignment=Qt.AlignmentFlag.AlignHCenter)
col.addWidget(slider, stretch=1, alignment=Qt.AlignmentFlag.AlignHCenter)
col.addWidget(label, alignment=Qt.AlignmentFlag.AlignHCenter)
holder = QWidget()
holder.setLayout(col)
holder.setFixedWidth(64)
self.volume[v.name] = slider
self._compact_hidden.append(holder)
return holder
def speed_col(v): def speed_col(v):
col = QVBoxLayout() col = QVBoxLayout()
col.setSpacing(4) col.setSpacing(4)
col.addWidget(fader_title("TEMPO", v), alignment=Qt.AlignmentFlag.AlignHCenter)
top = QLabel("+8%") top = QLabel("+8%")
bottom = QLabel("−8%") bottom = QLabel("−8%")
slider = QSlider(Qt.Orientation.Vertical) slider = QSlider(Qt.Orientation.Vertical)
@@ -519,9 +799,10 @@ class DjShelf(QWidget):
label.setMinimumWidth(60) label.setMinimumWidth(60)
for w in (top, bottom): for w in (top, bottom):
w.setStyleSheet(f"color: {DIM}; font-size: 10px;") w.setStyleSheet(f"color: {DIM}; font-size: 10px;")
slider.setFocusPolicy(Qt.FocusPolicy.NoFocus)
for w in (top, slider, bottom, label): for w in (top, slider, bottom, label):
col.addWidget(w, alignment=Qt.AlignmentFlag.AlignHCenter) col.addWidget(w, alignment=Qt.AlignmentFlag.AlignHCenter)
col.setStretch(1, 1) col.setStretch(2, 1)
holder = QWidget() holder = QWidget()
holder.setLayout(col) holder.setLayout(col)
holder.setFixedWidth(64) holder.setFixedWidth(64)
@@ -617,6 +898,7 @@ class DjShelf(QWidget):
nums.addWidget(bpm) nums.addWidget(bpm)
nums.addWidget(note) nums.addWidget(note)
line.addLayout(nums) line.addLayout(nums)
line.addWidget(self._mult_switch(v))
pitch = QCheckBox("Keep pitch") pitch = QCheckBox("Keep pitch")
pitch.setChecked(True) pitch.setChecked(True)
pitch.setFocusPolicy(Qt.FocusPolicy.NoFocus) pitch.setFocusPolicy(Qt.FocusPolicy.NoFocus)
@@ -634,38 +916,89 @@ class DjShelf(QWidget):
return line return line
a, b = self.views a, b = self.views
row.addWidget(volume_col(a))
row.addWidget(speed_col(a)) row.addWidget(speed_col(a))
row.addWidget(deck_col(a)) row.addWidget(deck_col(a))
centre = QVBoxLayout() centre = QVBoxLayout()
centre.setSpacing(6) centre.setSpacing(6)
horn_row = QHBoxLayout()
horn_row.addStretch(1)
self.horn = HornButton(self.mixer.horn)
horn_row.addWidget(self.horn)
horn_row.addStretch(1)
centre.addLayout(horn_row)
self._compact_hidden.append(self.horn)
centre.addLayout(info_row(a)) centre.addLayout(info_row(a))
self.lanes = WaveLanes(self) self.lanes = WaveLanes(self)
centre.addWidget(self.lanes, stretch=1) centre.addWidget(self.lanes, stretch=1)
centre.addLayout(info_row(b)) centre.addLayout(info_row(b))
fader = QHBoxLayout() fader = QHBoxLayout()
fader.setContentsMargins(60, 2, 60, 6) fader.setContentsMargins(0, 2, 0, 4)
fader.addStretch(1)
left = QLabel("A") left = QLabel("A")
left.setStyleSheet(f"color: {COLORS['A'].name()}; font-weight: bold;") left.setStyleSheet(f"color: {COLORS['A'].name()}; font-weight: bold;")
right = QLabel("B") right = QLabel("B")
right.setStyleSheet(f"color: {COLORS['B'].name()}; font-weight: bold;") right.setStyleSheet(f"color: {COLORS['B'].name()}; font-weight: bold;")
self.crossfader = QSlider(Qt.Orientation.Horizontal) self.crossfader = Crossfader()
self.crossfader.setRange(0, 1000)
self.crossfader.setValue(500)
self.crossfader.setStyleSheet(_slider_qss(None, vertical=False))
self.crossfader.setToolTip("Crossfader (double-click: centre)")
self.crossfader.valueChanged.connect(lambda value: setattr(self.mixer, "crossfader", value / 1000)) self.crossfader.valueChanged.connect(lambda value: setattr(self.mixer, "crossfader", value / 1000))
self.crossfader.mouseDoubleClickEvent = lambda e: self.crossfader.setValue(500)
fader.addWidget(left) fader.addWidget(left)
fader.addWidget(self.crossfader, stretch=1) fader.addWidget(self.crossfader, stretch=3)
fader.addWidget(right) fader.addWidget(right)
fader.addStretch(1)
centre.addLayout(fader) centre.addLayout(fader)
row.addLayout(centre, stretch=1) row.addLayout(centre, stretch=1)
row.addWidget(deck_col(b)) row.addWidget(deck_col(b))
row.addWidget(speed_col(b)) row.addWidget(speed_col(b))
row.addWidget(volume_col(b))
self._small_records = {} self._small_records = {}
for v in self.views: for v in self.views:
self._refresh_deck(v) self._refresh_deck(v)
def _mult_switch(self, v):
"""½× · 1× · 2×: count this song's beats at half or double its
tempo (half-time / double-time) — for display, the beat ticks and
what Sync lines up."""
box = QWidget()
row = QHBoxLayout(box)
row.setContentsMargins(0, 0, 0, 0)
row.setSpacing(0)
group = []
for i, (label, mult, tip) in enumerate((
("½×", 0.5, "Half-time: count every other beat"),
("1×", 1.0, "The song's own tempo"),
("2×", 2.0, "Double-time: count twice as many beats"))):
b = QToolButton()
b.setText(label)
b.setCheckable(True)
b.setChecked(mult == 1.0)
b.setAutoExclusive(True)
b.setToolTip(tip)
b.setFocusPolicy(Qt.FocusPolicy.NoFocus)
b.setFixedSize(30, 24)
radius = ("border-top-right-radius: 0; border-bottom-right-radius: 0;" if i == 0
else "border-top-left-radius: 0; border-bottom-left-radius: 0;" if i == 2
else "border-radius: 0;")
left = "" if i == 0 else "border-left: none;"
top, bottom = FACES[v.name]
b.setStyleSheet(
f"QToolButton {{ color: #cfcfcf; border: 1px solid #111; border-radius: 5px;"
f" background: #3a3b3d; padding: 0; {radius} {left} }}"
f"QToolButton:hover {{ background: #46474a; }}"
f"QToolButton:pressed {{ background: #2a2b2d; }}"
f"QToolButton:checked {{ color: white; background: qlineargradient("
f"x1:0,y1:0,x2:0,y2:1, stop:0 {top}, stop:1 {bottom}); }}")
b.clicked.connect(lambda _=False, v=v, m=mult: self.set_mult(v, m))
row.addWidget(b)
group.append(b)
self.mult_buttons[v.name] = group
return box
def set_mult(self, view: DeckView, mult: float):
view.mult = mult
for b, m in zip(self.mult_buttons[view.name], (0.5, 1.0, 2.0)):
b.setChecked(m == mult)
self._refresh_deck(view)
def resizeEvent(self, event): def resizeEvent(self, event):
super().resizeEvent(event) super().resizeEvent(event)
compact = self.height() < COMPACT_HEIGHT compact = self.height() < COMPACT_HEIGHT
@@ -709,6 +1042,15 @@ class DjShelf(QWidget):
for v in self.views: for v in self.views:
self._refresh_deck(v) self._refresh_deck(v)
def set_visualizer(self, visualizer):
"""Feed the mix to the transport's visualizer (None: stop)."""
if self._visualizer is not None and visualizer is None:
self._visualizer.set_dj_source(None)
self._visualizer = visualizer
self.mixer.tap.clear()
if visualizer is not None:
visualizer.set_dj_source(self.visual)
def set_master(self, linear: float): def set_master(self, linear: float):
self.mixer.master = max(0.0, min(1.0, float(linear))) self.mixer.master = max(0.0, min(1.0, float(linear)))
@@ -769,6 +1111,7 @@ class DjShelf(QWidget):
view.stem_note = "Loading…" view.stem_note = "Loading…"
self.speed[view.name].setValue(0) self.speed[view.name].setValue(0)
self.vocal_sliders[view.name].setValue(0) self.vocal_sliders[view.name].setValue(0)
self.set_mult(view, 1.0)
try: try:
art = tagging.read_embedded_artwork(track.location) art = tagging.read_embedded_artwork(track.location)
except Exception: # noqa: BLE001 — art is never worth a failure except Exception: # noqa: BLE001 — art is never worth a failure
@@ -872,13 +1215,13 @@ class DjShelf(QWidget):
missing = view if not view.bpm else other missing = view if not view.bpm else other
self.message.emit(f"Can't sync: no beat was found in “{missing.track.name}”.") self.message.emit(f"Can't sync: no beat was found in “{missing.track.name}”.")
return return
target = other.bpm * other.deck.speed target = other.beat_bpm * other.deck.speed
view.deck.speed = analysis.sync_ratio(view.bpm, target) view.deck.speed = analysis.sync_speed(view.beat_bpm, target)
self._show_speed(view) self._show_speed(view)
if view.deck.playing and other.deck.playing: if view.deck.playing and other.deck.playing:
own = analysis.beat_phase(self.heard_seconds(view), view.offset, view.bpm) own = analysis.beat_phase(self.heard_seconds(view), view.offset, view.beat_bpm)
theirs = analysis.beat_phase(self.heard_seconds(other), other.offset, other.bpm) theirs = analysis.beat_phase(self.heard_seconds(other), other.offset, other.beat_bpm)
shift = analysis.phase_shift(own, theirs, view.bpm) shift = analysis.phase_shift(own, theirs, view.beat_bpm)
view.deck.seek(view.deck.position + shift * RATE) view.deck.seek(view.deck.position + shift * RATE)
self.message.emit(f"Deck {view.name} synced to Deck {other.name}: " self.message.emit(f"Deck {view.name} synced to Deck {other.name}: "
f"{target:.1f} BPM, beats lined up") f"{target:.1f} BPM, beats lined up")
@@ -924,12 +1267,11 @@ class DjShelf(QWidget):
else "CUED" if deck.source is not None else "EMPTY") else "CUED" if deck.source is not None else "EMPTY")
self.states[view.name].setText(f"DECK {view.name} · {state}") self.states[view.name].setText(f"DECK {view.name} · {state}")
speed = deck.speed speed = deck.speed
if view.bpm: if view.beat_bpm:
self.bpm_labels[view.name].setText(f"{view.bpm * speed:.1f}") self.bpm_labels[view.name].setText(f"{view.beat_bpm * speed:.1f}")
pct = (speed - 1.0) * 100 pct = (speed - 1.0) * 100
change = f" · {pct:+.1f}%" if abs(pct) >= 0.05 else "" change = f" · {pct:+.1f}%" if abs(pct) >= 0.05 else ""
saved = " · calculated, saved" if view.bpm_saved else "" self.bpm_notes[view.name].setText(f"BPM · original {view.beat_bpm:.1f}{change}")
self.bpm_notes[view.name].setText(f"BPM · original {view.bpm:.1f}{change}{saved}")
else: else:
self.bpm_labels[view.name].setText("–") self.bpm_labels[view.name].setText("–")
self.bpm_notes[view.name].setText("BPM") self.bpm_notes[view.name].setText("BPM")
@@ -943,6 +1285,16 @@ class DjShelf(QWidget):
self._refresh_note(view) self._refresh_note(view)
def _tick(self): def _tick(self):
viz = self._visualizer
tap = self.mixer.tap
while tap:
start, mono = tap.popleft()
if viz is not None:
viz.feed_dj(mono, RATE, start * 1000.0 / RATE)
sounding = self.visual.is_playing()
if viz is not None and sounding != self._sounding:
viz.dj_playing_changed()
self._sounding = sounding
for v in self.views: for v in self.views:
deck = v.deck deck = v.deck
if deck.ended and not v.counted and v.track is not None: if deck.ended and not v.counted and v.track is not None:
@@ -957,8 +1309,8 @@ class DjShelf(QWidget):
self.lanes.update() self.lanes.update()
def _refresh_bpm_only(self, view: DeckView): def _refresh_bpm_only(self, view: DeckView):
if view.bpm: if view.beat_bpm:
self.bpm_labels[view.name].setText(f"{view.bpm * view.deck.speed:.1f}") self.bpm_labels[view.name].setText(f"{view.beat_bpm * view.deck.speed:.1f}")
def _pixel_max(peaks: np.ndarray, idx: np.ndarray, widest: int = 8) -> np.ndarray: def _pixel_max(peaks: np.ndarray, idx: np.ndarray, widest: int = 8) -> np.ndarray:
+84 -2
View File
@@ -160,6 +160,7 @@ class MainWindow(QMainWindow):
layout.addWidget(self._transport) layout.addWidget(self._transport)
# DJ mode (Round 93): the shelf is made the first time it opens. # DJ mode (Round 93): the shelf is made the first time it opens.
self._dj = None self._dj = None
self._dj_prep_worker = None
self._dj_on = False self._dj_on = False
self._dj_anim = None self._dj_anim = None
self._dj_resize_from = None self._dj_resize_from = None
@@ -302,6 +303,7 @@ class MainWindow(QMainWindow):
self._cassette.show_friend_menu) self._cassette.show_friend_menu)
self._sidebar.playlist_selected.connect(self._show_playlist) self._sidebar.playlist_selected.connect(self._show_playlist)
self._sidebar.tree.export_requested.connect(self._export_playlist) self._sidebar.tree.export_requested.connect(self._export_playlist)
self._sidebar.tree.dj_prepare_requested.connect(self._prepare_playlist_for_dj)
self._sidebar.art.download_art_requested.connect( self._sidebar.art.download_art_requested.connect(
lambda tid: self._download_album_art([tid])) lambda tid: self._download_album_art([tid]))
self._content.currentChanged.connect(self._update_totals) self._content.currentChanged.connect(self._update_totals)
@@ -314,6 +316,7 @@ class MainWindow(QMainWindow):
view.table.download_art_requested.connect(self._download_album_art) view.table.download_art_requested.connect(self._download_album_art)
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.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))
view.table.delete_from_library_requested.connect( view.table.delete_from_library_requested.connect(
@@ -668,12 +671,16 @@ class MainWindow(QMainWindow):
for worker in (self._andtunes_planner, self._andtunes_worker, for worker in (self._andtunes_planner, self._andtunes_worker,
self._export_worker, self._url_worker, self._export_worker, self._url_worker,
self._bpm_worker, self._server_check, self._bpm_worker, self._server_check,
self._upload_worker): self._upload_worker, self._dj_prep_worker):
if worker is not None and worker.busy(): if worker is not None and worker.busy():
return worker return worker
return None return None
def _confirm_cancel_sync(self): def _confirm_cancel_sync(self):
if self._dj_prep_worker is not None and self._dj_prep_worker.busy():
# What's prepared is kept; the song being split is abandoned.
self._dj_prep_worker.cancel()
return
if self._bpm_worker is not None and self._bpm_worker.busy(): if self._bpm_worker is not None and self._bpm_worker.busy():
# Nothing to lose: what's been measured is kept. # Nothing to lose: what's been measured is kept.
self._bpm_worker.cancel() self._bpm_worker.cancel()
@@ -2077,6 +2084,77 @@ class MainWindow(QMainWindow):
return return
self._enqueue_identify(tracks) self._enqueue_identify(tracks)
# ---- Prepare for DJ ----
def _prepare_playlist_for_dj(self, pid: str):
playlist = self._manager.library.playlists.get(pid)
if playlist is not None:
self._prepare_for_dj(list(playlist.track_ids))
def _prepare_for_dj(self, track_ids: list[int]):
"""BPM and vocals for these songs now, so they load onto a deck
instantly — with the vocals model chosen in Preferences › DJ."""
from lintunes.dj import stems
from lintunes.dj.prepare import DjPrepWorker
if self._busy_worker() is not None:
self.statusBar().showMessage(
"Wait for the current transfer to finish first", 6000)
return
if not stems.available():
QMessageBox.information(
self, "Prepare for DJ",
"Separating vocals needs Demucs, which isn't set up on this "
"computer. It's a one-time ~1 GB download:\n\n" + stems.setup_command())
return
items, seen = [], set()
for tid in track_ids:
track = self._manager.library.tracks.get(tid)
if track is None or not track.location or tid in seen:
continue
seen.add(tid)
label = (f"{track.artist} — {track.name}" if track.artist
else track.name) or Path(track.location).name
items.append((tid, track.location, label, bool(track.bpm)))
if not items:
return
model = stems.model_choice(self._prefs)
worker = DjPrepWorker(items, model, stems.gentle_choice(self._prefs), self)
self._dj_prep_bpm = {}
worker.bpm_found.connect(self._dj_prep_bpm.__setitem__)
worker.progress.connect(self._on_dj_prep_progress)
worker.finished.connect(self._on_dj_prep_finished)
self._dj_prep_worker = worker
self._sync_label.setText(f"Preparing for DJ ({stems.MODELS[model][0]})…")
self._sync_progress.setRange(0, len(items))
self._sync_progress.setValue(0)
self._sync_cancel.show()
self._sync_label.show()
self._sync_progress.show()
worker.start()
def _on_dj_prep_progress(self, done: int, total: int, label: str):
self._sync_progress.setRange(0, total)
self._sync_progress.setValue(done)
if label:
short = label if len(label) <= 48 else label[:47] + "…"
where = f"{done + 1} of {total} · " if total > 1 else ""
self._sync_label.setText(f"DJ {where}{short}")
def _on_dj_prep_finished(self, summary: dict):
self._hide_sync_widgets()
found, self._dj_prep_bpm = self._dj_prep_bpm, {}
if found:
self._manager.set_tracks_bpm(found)
msg = (f"Prepared {summary['done']} song(s) for DJ"
f" · {summary['split']} vocals separated · {summary['bpm']} BPM found")
if summary["cancelled"]:
msg = "Prepare for DJ stopped — " + msg[0].lower() + msg[1:]
if summary["failed"]:
msg += f" · {summary['failed']} couldn't be done"
if not summary["cancelled"]:
sounds.play_done(self._prefs)
self.statusBar().showMessage(msg, 12000)
# ---- Calculate BPM ---- # ---- Calculate BPM ----
def _calculate_bpm(self, track_ids: list[int]): def _calculate_bpm(self, track_ids: list[int]):
@@ -2323,6 +2401,8 @@ class MainWindow(QMainWindow):
shelf.setFixedHeight(0) shelf.setFixedHeight(0)
shelf.show() shelf.show()
shelf.start() shelf.start()
shelf.set_visualizer(self._transport._visualizer)
self._sidebar.art.hide() # room for the lists instead
self._animate_shelf(0, target) self._animate_shelf(0, target)
else: else:
shelf = self._dj shelf = self._dj
@@ -2333,7 +2413,7 @@ class MainWindow(QMainWindow):
def _ensure_dj(self): def _ensure_dj(self):
if self._dj is None: if self._dj is None:
from lintunes.gui.dj_shelf import DjShelf from lintunes.gui.dj_shelf import DjShelf
shelf = DjShelf(self._manager) shelf = DjShelf(self._manager, self._prefs)
shelf.hide() shelf.hide()
shelf.message.connect(lambda msg: self.statusBar().showMessage(msg, 8000)) shelf.message.connect(lambda msg: self.statusBar().showMessage(msg, 8000))
shelf.decks_changed.connect(self._on_decks_changed) shelf.decks_changed.connect(self._on_decks_changed)
@@ -2394,8 +2474,10 @@ class MainWindow(QMainWindow):
def _dj_closed(self): def _dj_closed(self):
if self._dj_on: if self._dj_on:
return # reopened mid-close return # reopened mid-close
self._dj.set_visualizer(None)
self._dj.stop() self._dj.stop()
self._dj.hide() self._dj.hide()
self._sidebar.art.show()
self.player.set_suspended(False) self.player.set_suspended(False)
self._transport.set_dj_mode(False) self._transport.set_dj_mode(False)
+35
View File
@@ -125,6 +125,7 @@ class PreferencesDialog(QDialog):
("Appearance", [self._build_general_group(), ("Appearance", [self._build_general_group(),
self._build_visualizer_group(), self._build_visualizer_group(),
self._build_colors_group()]), self._build_colors_group()]),
("DJ", [self._build_dj_group()]),
("Integrations", [self._build_lastfm_group(), ("Integrations", [self._build_lastfm_group(),
self._build_acoustid_group(), self._build_acoustid_group(),
self._build_web_server_group()])): self._build_web_server_group()])):
@@ -252,6 +253,40 @@ class PreferencesDialog(QDialog):
row.addWidget(preview) row.addWidget(preview)
return group return group
# ---- DJ ----
def _build_dj_group(self) -> QGroupBox:
"""Vocals separation (Demucs): which model, and how hard it may run
the CPU. Both apply to the next song split."""
from lintunes.dj import stems
group = QGroupBox("Separating vocals")
form = QFormLayout(group)
model = QComboBox()
for key, (label, cost) in stems.MODELS.items():
model.addItem(f"{label} — {cost}", key)
model.setCurrentIndex(max(0, model.findData(stems.model_choice(self._prefs))))
model.currentIndexChanged.connect(
lambda _i: self._prefs.set("dj_stem_model", model.currentData()))
form.addRow("Model:", model)
gentle = QCheckBox("Gentle on the CPU: a quarter of the cores, lowest "
"priority (cooler, a little slower)")
gentle.setChecked(stems.gentle_choice(self._prefs))
gentle.toggled.connect(lambda on: self._prefs.set("dj_stem_gentle", on))
form.addRow("", gentle)
if stems.available():
note = QLabel("Demucs is set up. Songs are split when they load onto "
"a deck, or ahead of time with a playlist's or "
"song's “Prepare for DJ”. Splits are kept.")
else:
note = QLabel("Demucs isn't set up on this computer (a one-time ~1 GB "
"download). In a terminal:\n" + stems.setup_command())
note.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
note.setWordWrap(True)
form.addRow("", note)
self._dj_model_combo = model
self._dj_gentle_check = gentle
return group
# ---- Wrapped ---- # ---- Wrapped ----
def _build_wrapped_group(self) -> QGroupBox: def _build_wrapped_group(self) -> QGroupBox:
+9 -3
View File
@@ -182,13 +182,15 @@ class SidebarPanel(QWidget):
split = not self.friend_button.isHidden() split = not self.friend_button.isHidden()
joint = ("border-top-right-radius: 0; border-bottom-right-radius: 0;" joint = ("border-top-right-radius: 0; border-bottom-right-radius: 0;"
if split else "") if split else "")
# The transport buttons' corners (8 px), not the dialogs' 4.
self.library_button.setStyleSheet(theme.button_face_qss( self.library_button.setStyleSheet(theme.button_face_qss(
"QPushButton", base, extra=f"text-align: left; padding-left: 10px; {joint}", "QPushButton", base, radius=8,
extra=f"text-align: left; padding-left: 10px; {joint}",
checked_color=lit, checked_text=checked_text)) checked_color=lit, checked_text=checked_text))
# The ▾ is the same button cut off at the end: same face, no left # The ▾ is the same button cut off at the end: same face, no left
# border (it shares the Library button's), square where they meet. # border (it shares the Library button's), square where they meet.
self.friend_button.setStyleSheet(theme.button_face_qss( self.friend_button.setStyleSheet(theme.button_face_qss(
"QPushButton", base, "QPushButton", base, radius=8,
extra="padding: 0; border-left: none; border-top-left-radius: 0;" extra="padding: 0; border-left: none; border-top-left-radius: 0;"
" border-bottom-left-radius: 0;")) " border-bottom-left-radius: 0;"))
@@ -474,6 +476,7 @@ class PlaylistTree(QTreeWidget):
playlist_selected = pyqtSignal(str) # persistent_id playlist_selected = pyqtSignal(str) # persistent_id
export_requested = pyqtSignal(str) # persistent_id export_requested = pyqtSignal(str) # persistent_id
dj_prepare_requested = pyqtSignal(str) # persistent_id
# A friend's playlist I follow (key "cassette:<token>:<their pid>"). # A friend's playlist I follow (key "cassette:<token>:<their pid>").
followed_selected = pyqtSignal(str) followed_selected = pyqtSignal(str)
unfollow_requested = pyqtSignal(str) unfollow_requested = pyqtSignal(str)
@@ -846,7 +849,7 @@ class PlaylistTree(QTreeWidget):
new_playlist = menu.addAction("New Playlist") new_playlist = menu.addAction("New Playlist")
new_smart = menu.addAction("New Smart Playlist") new_smart = menu.addAction("New Smart Playlist")
new_folder = menu.addAction("New Playlist Folder") new_folder = menu.addAction("New Playlist Folder")
rename = delete = edit_smart = export = None rename = delete = edit_smart = export = dj_prepare = None
if kind in ("playlist", "folder", "smart"): if kind in ("playlist", "folder", "smart"):
menu.addSeparator() menu.addSeparator()
if kind == "smart": if kind == "smart":
@@ -856,6 +859,7 @@ class PlaylistTree(QTreeWidget):
if kind in ("playlist", "smart"): if kind in ("playlist", "smart"):
menu.addSeparator() menu.addSeparator()
export = menu.addAction("Export Playlist…") export = menu.addAction("Export Playlist…")
dj_prepare = menu.addAction("Prepare for DJ")
chosen = menu.exec(self.viewport().mapToGlobal(pos)) chosen = menu.exec(self.viewport().mapToGlobal(pos))
if chosen is None: if chosen is None:
@@ -873,6 +877,8 @@ class PlaylistTree(QTreeWidget):
self._manager.create_folder(name.strip(), parent_pid) self._manager.create_folder(name.strip(), parent_pid)
elif export is not None and chosen is export: elif export is not None and chosen is export:
self.export_requested.emit(pid) self.export_requested.emit(pid)
elif dj_prepare is not None and chosen is dj_prepare:
self.dj_prepare_requested.emit(pid)
elif rename is not None and chosen is rename: elif rename is not None and chosen is rename:
self.editItem(item, 0) self.editItem(item, 0)
elif delete is not None and chosen is delete: elif delete is not None and chosen is delete:
+7 -1
View File
@@ -707,6 +707,7 @@ class TrackTableView(QTableView):
download_art_requested = pyqtSignal(list) # selected track ids download_art_requested = pyqtSignal(list) # selected track ids
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
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
@@ -1028,7 +1029,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 = None identify_action = bpm_action = dj_action = None
if locations: if locations:
menu.addSeparator() menu.addSeparator()
reveal_action = menu.addAction("Reveal in File Browser") reveal_action = menu.addAction("Reveal in File Browser")
@@ -1037,6 +1038,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")
dj_action = menu.addAction("Prepare for DJ")
dj_action.setToolTip("Work out BPM and separate vocals now, so "
"these load instantly onto a deck")
# Single track only: one click shouldn't open a browser tab per song. # Single track only: one click shouldn't open a browser tab per song.
# Needs no file, so it's offered for a dangling location too. # Needs no file, so it's offered for a dangling location too.
@@ -1092,6 +1096,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 dj_action is not None and chosen is dj_action:
self.dj_prepare_requested.emit(self.selected_track_ids())
elif youtube_action is not None and chosen is youtube_action: elif youtube_action is not None and chosen is youtube_action:
track = self.model_.track_at(self.selected_source_rows()[0]) track = self.model_.track_at(self.selected_source_rows()[0])
QDesktopServices.openUrl(youtube_search_url(track)) QDesktopServices.openUrl(youtube_search_url(track))
+1 -1
View File
@@ -633,7 +633,7 @@ class TransportBar(QWidget):
def _apply_dj_button_style(self): def _apply_dj_button_style(self):
bg = theme.gray(theme.gray_value(self._prefs, "color_button")) bg = theme.gray(theme.gray_value(self._prefs, "color_button"))
self.dj_button.setStyleSheet(theme.button_face_qss( self.dj_button.setStyleSheet(theme.button_face_qss(
"QToolButton#djButton", bg, extra="padding: 0;", "QToolButton#djButton", bg, radius=8, extra="padding: 0;",
checked_color=bg.darker(theme.CHECKED_DARKER))) checked_color=bg.darker(theme.CHECKED_DARKER)))
def _on_dj_button(self, on: bool): def _on_dj_button(self, on: bool):
+18
View File
@@ -107,6 +107,7 @@ class VisualizerWidget(QWidget):
self._timer.setInterval(FRAME_MS) self._timer.setInterval(FRAME_MS)
self._timer.timeout.connect(self._advance_frame) self._timer.timeout.connect(self._advance_frame)
self._own_player = player
player.audio_buffer.connect(self._on_buffer) player.audio_buffer.connect(self._on_buffer)
player.playing_changed.connect(self._on_playing_changed) player.playing_changed.connect(self._on_playing_changed)
player.track_changed.connect(self._on_track_changed) player.track_changed.connect(self._on_track_changed)
@@ -159,6 +160,23 @@ class VisualizerWidget(QWidget):
self._sync_timer() self._sync_timer()
self.update() self.update()
# ---- DJ mode ----
def set_dj_source(self, source):
"""DJ mode (Round 94): draw the decks' mix instead of the player.
``source`` answers ``position_ms()`` (what's heard) and
``is_playing()``; its audio arrives through ``feed_dj``. None goes
back to the player."""
self._player = source if source is not None else self._own_player
self._reset_stream()
self._sync_timer()
def feed_dj(self, mono, rate, start_ms):
self._feed(mono, rate, start_ms)
def dj_playing_changed(self):
self._sync_timer()
# ---- audio intake ---- # ---- audio intake ----
def _on_buffer(self, buf): def _on_buffer(self, buf):
+1 -1
View File
@@ -239,7 +239,7 @@ class TestPreferencesPages:
dialog = PreferencesDialog(Preferences(tmp_path), _FakeLastFm()) dialog = PreferencesDialog(Preferences(tmp_path), _FakeLastFm())
names = [dialog.pages_list.item(i).text() names = [dialog.pages_list.item(i).text()
for i in range(dialog.pages_list.count())] for i in range(dialog.pages_list.count())]
assert names == ["General", "Appearance", "Integrations"] assert names == ["General", "Appearance", "DJ", "Integrations"] # DJ: Round 94
dialog.pages_list.setCurrentRow(2) dialog.pages_list.setCurrentRow(2)
assert dialog.pages.currentIndex() == 2 assert dialog.pages.currentIndex() == 2
PreferencesDialog._last_page = 0 PreferencesDialog._last_page = 0
+2 -1
View File
@@ -189,6 +189,8 @@ def shelf(qapp, monkeypatch):
made.tracks = tracks made.tracks = tracks
yield made yield made
made.stop() made.stop()
from PyQt6 import sip
sip.delete(made) # deleted here, never by a GC on some thread
class TestShelf: class TestShelf:
@@ -196,7 +198,6 @@ class TestShelf:
a, _ = shelf.views a, _ = shelf.views
_loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 10), 124.0, 0.1) _loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 10), 124.0, 0.1)
shelf._manager.set_tracks_bpm.assert_called_once_with({1: 124}) shelf._manager.set_tracks_bpm.assert_called_once_with({1: 124})
assert "calculated, saved" in shelf.bpm_notes["A"].text()
assert shelf.bpm_labels["A"].text() == "124.0" assert shelf.bpm_labels["A"].text() == "124.0"
def test_sync_matches_tempo_and_then_beats(self, shelf): def test_sync_matches_tempo_and_then_beats(self, shelf):
+209
View File
@@ -0,0 +1,209 @@
"""Round 94: DJ mode, round two — the crossfader (big handle, a middle line,
a snap to centre), ½×/1×/2× beat counting, scrubbing by the waveform, deck
volumes, the air horn, the visualizer fed by the mix, vocals models and
gentle CPU use, and Prepare for DJ."""
import threading
from types import SimpleNamespace
from unittest.mock import MagicMock
import numpy as np
import pytest
from PyQt6.QtCore import QEvent, QPointF, Qt
from PyQt6.QtGui import QMouseEvent
from lintunes.dj import analysis, stems
from lintunes.dj.audio import RATE, Mixer
from tests.test_round93 import _clicks, _loaded, shelf # noqa: F401 — the fixture
def _mouse(kind, x, y=20.0):
return QMouseEvent(kind, QPointF(x, y), QPointF(x, y), Qt.MouseButton.LeftButton,
Qt.MouseButton.LeftButton, Qt.KeyboardModifier.NoModifier)
class TestCrossfader:
def test_snaps_to_the_middle_when_close(self, qapp):
from lintunes.gui.dj_shelf import Crossfader
fader = Crossfader()
fader.resize(428, fader.height()) # 400 px of travel
lo, hi = fader._span()
near = lo + (hi - lo) * 0.52
fader.mousePressEvent(_mouse(QEvent.Type.MouseButtonPress, lo))
fader.mouseMoveEvent(_mouse(QEvent.Type.MouseMove, near))
assert fader.value() == 500
fader.mouseMoveEvent(_mouse(QEvent.Type.MouseMove, lo + (hi - lo) * 0.6))
assert fader.value() == 600
fader.mouseReleaseEvent(_mouse(QEvent.Type.MouseButtonRelease, 0))
assert fader.value() == 600
def test_handle_is_big(self, qapp):
from lintunes.gui.dj_shelf import Crossfader
assert Crossfader.HANDLE.height() >= 40 and Crossfader.HANDLE.width() > 20
class TestBeatCounting:
def test_double_time_shows_and_syncs_at_twice(self, shelf):
a, b = shelf.views
_loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 5), 124.0, 0.1)
_loaded(shelf, b, shelf.tracks[1], _clicks(62, 0.1, 5), 62.0, 0.1)
shelf.set_mult(b, 2.0)
assert shelf.bpm_labels["B"].text() == "124.0"
shelf.sync(b)
assert b.deck.speed == pytest.approx(1.0)
shelf.set_mult(b, 0.5)
assert shelf.bpm_labels["B"].text() == "31.0"
def test_sync_speed(self):
assert analysis.sync_speed(118, 124) == pytest.approx(124 / 118)
# 62 counted against 124 is an octave apart: speed stays near 1
assert analysis.sync_speed(62, 124) == pytest.approx(1.0)
def test_dragging_a_waveform_scrubs(shelf):
a, _ = shelf.views
_loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 5), 124.0, 0.1)
lanes = shelf.lanes
lanes.resize(800, 100)
lanes.mousePressEvent(_mouse(QEvent.Type.MouseButtonPress, 400, 10))
assert a.deck.scratch_rate == 0.0
lanes.mouseMoveEvent(_mouse(QEvent.Type.MouseMove, 500, 10)) # drag right
assert a.deck.scratch_rate < 0 # → backwards
lanes.mouseReleaseEvent(_mouse(QEvent.Type.MouseButtonRelease, 500, 10))
assert a.deck.scratch_rate is None
def test_deck_volume_and_horn():
mixer = Mixer()
mixer.crossfader = 0.0
mixer.a.volume = 0.5
assert mixer.deck_gain(mixer.a) == pytest.approx(0.5)
mixer.horn.on = True
loud = mixer.render(4410)
assert np.abs(loud).max() > 0.1
mixer.horn.on = False
mixer.render(RATE // 2)
assert mixer.horn.render(64) is None # it has died away
assert len(mixer.tap) == 2 and mixer.rendered == 4410 + RATE // 2
def test_the_visualizer_draws_the_mix(shelf, qapp):
from lintunes.gui.visualizer import VisualizerWidget
player = MagicMock()
viz = VisualizerWidget(player, MagicMock(get=lambda k, d=None: d))
shelf.set_visualizer(viz)
assert viz._player is shelf.visual
shelf.mixer.render(2048)
shelf._tick()
assert viz._total == 2048
shelf.set_visualizer(None)
assert viz._player is player
from PyQt6 import sip
sip.delete(viz)
def test_the_volume_fader_is_perceptual(shelf):
a, _ = shelf.views
shelf.volume["A"].setValue(50)
assert 0.0 < a.deck.volume < 0.5 # Qt's log curve: half travel is quieter
class TestStems:
def _song(self, tmp_path, monkeypatch):
song = tmp_path / "a.mp3"
song.write_bytes(b"x")
monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))
return str(song)
def _make(self, folder):
folder.mkdir(parents=True, exist_ok=True)
for name in stems.STEMS:
(folder / f"{name}.flac").write_bytes(b"f")
def test_the_best_split_wins_and_old_splits_count(self, tmp_path, monkeypatch):
song = self._song(tmp_path, monkeypatch)
root = stems.cache_root() / stems.cache_key(song)
self._make(root) # Round 93's layout
assert stems.cached(song)["vocals"].parent == root
assert stems.cached(song, "htdemucs") is not None
assert stems.cached(song, "htdemucs_ft") is None
self._make(root / "htdemucs_ft")
assert stems.cached(song)["vocals"].parent.name == "htdemucs_ft"
def test_gentle_uses_a_quarter_and_lowest_priority(self, tmp_path, monkeypatch):
song = self._song(tmp_path, monkeypatch)
monkeypatch.setattr(stems, "available", lambda: True)
monkeypatch.setattr(stems.os, "cpu_count", lambda: 8)
seen = {}
class Proc:
stderr = SimpleNamespace(read=lambda n: b"")
def wait(self):
return 1
def popen(cmd, **kw):
seen.update(cmd=cmd, env=kw["env"])
return Proc()
monkeypatch.setattr(stems.subprocess, "Popen", popen)
with pytest.raises(OSError):
stems.split(song, "htdemucs_fast", True)
assert seen["env"]["OMP_NUM_THREADS"] == "2"
assert "--overlap" in seen["cmd"] and "0.1" in seen["cmd"]
assert stems.threads(False) == 8
def test_prefs_choices(self):
prefs = {"dj_stem_model": "htdemucs_ft"}
assert stems.model_choice(prefs) == "htdemucs_ft"
assert stems.model_choice({"dj_stem_model": "nonsense"}) == stems.DEFAULT_MODEL
assert stems.gentle_choice({}) is True
def test_prepare_for_dj(monkeypatch, qapp):
import gc
from lintunes.dj import prepare
# A worker thread that allocates can run the garbage collector *on
# that thread*, destroying earlier tests' leftover widgets off the GUI
# thread — a segfault later. Collect them here, on this one, first.
gc.collect()
monkeypatch.setattr(prepare.stems, "available", lambda: True)
monkeypatch.setattr(prepare.stems, "cached", lambda path, model=None: None)
split = []
monkeypatch.setattr(prepare.stems, "split",
lambda path, model, gentle, tick, cancel: split.append((path, model, gentle)) or tick(50))
monkeypatch.setattr(prepare.bpm_detect, "detect_file", lambda path: 120)
worker = prepare.DjPrepWorker([(1, "/a.mp3", "A", False), (2, "/b.mp3", "B", True)],
"htdemucs_ft", True)
found, done = [], threading.Event()
result = {}
worker.bpm_found.connect(lambda tid, bpm: found.append((tid, bpm)))
worker.finished.connect(lambda summary: (result.update(summary), done.set()))
worker.start()
for _ in range(200):
qapp.processEvents()
if done.wait(0.01):
break
worker._thread.join(5) # never let the worker go while its thread emits
qapp.processEvents()
assert found == [(1, 120)]
assert split == [("/a.mp3", "htdemucs_ft", True), ("/b.mp3", "htdemucs_ft", True)]
assert result["done"] == 2 and result["split"] == 2 and not result["cancelled"]
def test_dj_mode_hides_the_sidebar_art(qapp, tmp_path, monkeypatch):
from lintunes.gui.main_window import MainWindow
from lintunes.library_manager import LibraryManager
from lintunes.models.library import Library
from lintunes.preferences import Preferences
monkeypatch.setattr("lintunes.gui.main_window.load_config", lambda: {})
monkeypatch.setattr("lintunes.gui.main_window.save_config", lambda c: None)
window = MainWindow(LibraryManager(Library(), tmp_path), Preferences(tmp_path))
try:
window.show()
window.set_dj_mode(True)
assert window._sidebar.art.isHidden()
window.set_dj_mode(False)
window._dj_anim.stop()
window._dj_closed()
assert not window._sidebar.art.isHidden()
finally:
window.close()