v0.65.0: DJ mode round three, and the small things

- The shelf is revealed in place: the decks don't stretch or squeeze as
  the window parts.
- The DJ button is the top row's last box (where bpm was), so it stays
  put; bpm moved under it.
- Tempo, vocals and the crossfader snap to their middle and show it. The
  vocals slider has icons, lined up with its ends and middle.
- Sync sticks: a synced deck follows the other's tempo, glows and says
  Synced until its own tempo fader moves. The ½×/1×/2× switch re-syncs,
  and the BPM line says when it's counted half or double.
- A back-to-the-start button per deck.
- The air horn is a real recording (CC0): tap for the phrase, hold to
  stretch the first blast.
- The zoomed waveforms ease out while a deck is paused or held.
- DJ audio follows a change of output device instead of going silent.
- A new playlist folder is named in place, scrolled into view.
- Visualizer bars: choose how many, 1 to 1024 (one per pixel at most).
- The volume slider is as tall as the scrubber.
This commit is contained in:
2026-10-17 04:00:34 -07:00
parent 6d6a0c2385
commit e00aafefba
21 changed files with 807 additions and 179 deletions
+16
View File
@@ -406,6 +406,22 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
air-horn button (held = longer; `audio.Horn`, synthesised). The air-horn button (held = longer; `audio.Horn`, synthesised). The
transport's visualizer draws the mix in DJ mode (`Mixer.tap` → transport's visualizer draws the mix in DJ mode (`Mixer.tap` →
`VisualizerWidget.set_dj_source/feed_dj`). The sidebar art hides. `VisualizerWidget.set_dj_source/feed_dj`). The sidebar art hides.
**Round 95**: the shelf is laid out at its full height on a body
(`set_layout_height`) and only *revealed* by the opening — the decks
never squeeze. The DJ button is the top row's last box (it swapped with
bpm, which is under it in the header row), so it doesn't move when the
window parts. `dj_shelf.SnapSlider` is every DJ slider with a middle
(tempo, vocals — `VocalSlider`, icons over its ends and middle —
crossfader): a centre line and a snap. Sync is **sticky**: a synced deck
follows the other's tempo every tick (`_follow`), glows and says
"Synced", until its own tempo fader moves; only one deck follows; the
½×/1×/2× switch re-syncs a synced pair (`sync_ratio` folds any number of
octaves). |◀ per deck. The air horn is a real recording
(`sounds/airhorn.mp3`, CC0, see `sounds/CREDITS.md`): a tap plays the
phrase, holding loops its first blast. The zoomed lanes ease out ×2
while a deck is paused or held. The sink reopens when the system's
default output changes (`output._Pump`: `audioOutputsChanged`, a device
id check, an error check) — it used to go silent until DJ mode reopened.
- **`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.64.0" __version__ = "0.65.0"
+6 -1
View File
@@ -134,7 +134,12 @@ def sync_ratio(own_bpm: float, target_bpm: float) -> float:
if not own_bpm or not target_bpm: if not own_bpm or not target_bpm:
return 1.0 return 1.0
ratio = target_bpm / own_bpm ratio = target_bpm / own_bpm
return min((ratio, ratio * 2, ratio / 2), key=lambda r: abs(np.log2(r))) # as many octaves as it takes (½× against 2× is two apart)
while ratio > 2 ** 0.5:
ratio /= 2
while ratio < 2 ** -0.5:
ratio *= 2
return ratio
def sync_speed(own_beat_bpm: float, target_beat_bpm: float, def sync_speed(own_beat_bpm: float, target_beat_bpm: float,
+67 -27
View File
@@ -231,39 +231,79 @@ def crossfade_gains(x: float) -> tuple[float, float]:
class Horn: class Horn:
"""The rap air horn, synthesised: three detuned, brassy sawtooths a """The air horn: a real recording ("Air Horn Hype", CC0 — see
rough major chord apart, through a soft clip, blaring for as long as lintunes/sounds/CREDITS.md), the classic BWAAH-bwah-bwah-BWAAAH.
``on`` is held (15 ms attack, 120 ms tail when let go).""" Pressed, it plays from the top; *held*, the first long blast is
stretched for as long as the button stays down (its steady middle,
``LOOP``, looped with a crossfade so the seam can't be heard); let go,
the rest of the phrase plays out. A tap is simply the whole phrase."""
FREQS = (369.99, 466.16, 554.37) # F#4, A#4, C#5 LOOP = (0.10, 0.40) # seconds: inside the first blast (0–0.48 s)
ATTACK, RELEASE = 0.015, 0.12 CROSSFADE = 0.03
LEVEL = 0.32 LEVEL = 1.0
def __init__(self): def __init__(self, sample: np.ndarray | None = None):
self.on = False
self._src = None
self._held = None
self._pos = None # None = silent
if sample is not None:
self.set_sample(sample)
def set_sample(self, sample: np.ndarray):
"""``sample``: (frames, 2) int16 or float."""
src = sample.astype(np.float32)
if sample.dtype == np.int16:
src /= 32768.0
self._src = src
l0, l1 = (int(t * RATE) for t in self.LOOP)
xf = int(self.CROSSFADE * RATE)
l1 = min(l1, len(src))
held = src.copy()
if l1 - l0 > 2 * xf and l0 >= xf:
ramp = np.linspace(0, 1, xf, dtype=np.float32)[:, None]
# the loop's last xf frames fade into what comes just before
# its start, so jumping back to l0 continues seamlessly
held[l1 - xf:l1] = src[l1 - xf:l1] * (1 - ramp) + src[l0 - xf:l0] * ramp
self._held = held
self._loop = (l0, l1, xf)
def press(self):
self.on = True
self._pos = 0
def release(self):
self.on = False self.on = False
self._phase = np.zeros(len(self.FREQS))
self._env = 0.0
def render(self, count: int) -> np.ndarray | None: def render(self, count: int) -> np.ndarray | None:
if not self.on and self._env <= 1e-4: if self._src is None or self._pos is None:
self._env = 0.0
return None return None
t = np.arange(count) / RATE l0, l1, xf = self._loop
target = 1.0 if self.on else 0.0 out = np.zeros((count, CHANNELS), np.float32)
step = 1.0 / ((self.ATTACK if self.on else self.RELEASE) * RATE) made = 0
env = np.clip(self._env + (step if self.on else -step) * np.arange(1, count + 1), while made < count:
0.0, 1.0) if target != self._env else np.full(count, self._env) pos = self._pos
self._env = float(env[-1]) if pos >= len(self._src):
wave = np.zeros(count) self._pos = None
for i, f in enumerate(self.FREQS): break
for detune in (0.997, 1.0, 1.004): if self.on or l1 - xf <= pos < l1 and pos >= l0:
phase = (self._phase[i] * detune + f * detune * t) % 1.0 # held (or finishing the crossfade lap): play the looped
wave += 2.0 * phase - 1.0 # version, wrapping at the loop's end
self._phase[i] = (self._phase[i] + f * count / RATE) % 1.0 take = min(count - made, (l1 - pos) if pos < l1 else len(self._src) - pos)
# a little flutter, like air through a reed if pos < l1:
wave *= 1.0 + 0.08 * np.sin(2 * np.pi * 7.0 * t) out[made:made + take] = self._held[pos:pos + take]
sound = np.tanh(wave / 3.0 * 1.8) * self.LEVEL * env self._pos = pos + take
return np.repeat(sound[:, None].astype(np.float32), CHANNELS, axis=1) if self._pos >= l1 and self.on:
self._pos = l0
else:
out[made:made + take] = self._src[pos:pos + take]
self._pos = pos + take
else:
take = min(count - made, len(self._src) - pos)
out[made:made + take] = self._src[pos:pos + take]
self._pos = pos + take
made += take
return out * self.LEVEL
class Mixer: class Mixer:
+42 -9
View File
@@ -11,7 +11,7 @@ here should exist for someone who never opens it).
import numpy as np import numpy as np
from PyQt6.QtCore import QObject, QThread, QTimer, pyqtSignal, pyqtSlot from PyQt6.QtCore import QObject, QThread, QTimer, pyqtSignal, pyqtSlot
from PyQt6.QtMultimedia import QAudioFormat, QAudioSink, QMediaDevices from PyQt6.QtMultimedia import QAudio, QAudioFormat, QAudioSink, QMediaDevices
from lintunes.dj.audio import CHANNELS, RATE from lintunes.dj.audio import CHANNELS, RATE
@@ -30,9 +30,22 @@ class _Pump(QObject):
self.io = None self.io = None
self.timer = None self.timer = None
self.queued_frames = 0 self.queued_frames = 0
self.device_id = b""
@pyqtSlot() @pyqtSlot()
def start(self): def start(self):
# Follow the system's output: a sink is opened on one device, and
# when that goes (headphones in, Bluetooth on) Qt doesn't move it —
# it just stops, and the decks went silent until DJ mode reopened.
self.devices = QMediaDevices()
self.devices.audioOutputsChanged.connect(self._reopen)
self.timer = QTimer()
self.timer.setInterval(TICK_MS)
self.timer.timeout.connect(self._fill)
self._open()
self.timer.start()
def _open(self) -> bool:
fmt = QAudioFormat() fmt = QAudioFormat()
fmt.setSampleRate(RATE) fmt.setSampleRate(RATE)
fmt.setChannelCount(CHANNELS) fmt.setChannelCount(CHANNELS)
@@ -40,17 +53,38 @@ class _Pump(QObject):
device = QMediaDevices.defaultAudioOutput() device = QMediaDevices.defaultAudioOutput()
if device.isNull() or not device.isFormatSupported(fmt): if device.isNull() or not device.isFormatSupported(fmt):
self.failed.emit("this computer's sound output can't play 44.1 kHz stereo") self.failed.emit("this computer's sound output can't play 44.1 kHz stereo")
return return False
self.sink = QAudioSink(device, fmt) self.sink = QAudioSink(device, fmt)
self.sink.setBufferSize(int(RATE * BUFFER_MS / 1000) * BYTES_PER_FRAME) self.sink.setBufferSize(int(RATE * BUFFER_MS / 1000) * BYTES_PER_FRAME)
self.io = self.sink.start() self.io = self.sink.start()
self.timer = QTimer() self.device_id = bytes(device.id())
self.timer.setInterval(TICK_MS) return True
self.timer.timeout.connect(self._fill)
self.timer.start() def _close(self):
if self.sink is not None:
self.sink.stop()
self.sink = self.io = None
@pyqtSlot()
def _reopen(self):
"""The default output changed (or this one broke): reopen on it."""
self._close()
self._open()
def _fill(self): def _fill(self):
if self.sink is None or self.io is None: if self.sink is None or self.io is None:
# No device a moment ago; try again about once a second.
self._retry = getattr(self, "_retry", 0) + 1
if self._retry * TICK_MS >= 1000:
self._retry = 0
self._open()
return
if self.sink.error() != QAudio.Error.NoError:
self._reopen()
return
current = QMediaDevices.defaultAudioOutput()
if not current.isNull() and bytes(current.id()) != self.device_id:
self._reopen() # the default moved without telling us
return return
free = self.sink.bytesFree() // BYTES_PER_FRAME free = self.sink.bytesFree() // BYTES_PER_FRAME
frames = free - free % 64 frames = free - free % 64
@@ -65,9 +99,8 @@ class _Pump(QObject):
def stop(self): def stop(self):
if self.timer is not None: if self.timer is not None:
self.timer.stop() self.timer.stop()
if self.sink is not None: self._close()
self.sink.stop() self.timer = None
self.sink = self.io = self.timer = None
class DjOutput(QObject): class DjOutput(QObject):
+336 -78
View File
@@ -23,7 +23,7 @@ import threading
import time import time
import numpy as np import numpy as np
from PyQt6.QtCore import QPointF, QRectF, QSize, Qt, QTimer, pyqtSignal from PyQt6.QtCore import QPointF, QRect, QRectF, QSize, Qt, QTimer, pyqtSignal
from PyQt6.QtGui import ( from PyQt6.QtGui import (
QBrush, QColor, QIcon, QImage, QLinearGradient, QPainter, QPainterPath, QPen, QBrush, QColor, QIcon, QImage, QLinearGradient, QPainter, QPainterPath, QPen,
QPixmap, QRadialGradient, QPixmap, QRadialGradient,
@@ -46,10 +46,12 @@ COLORS = {"A": QColor("#5a9be0"), "B": QColor("#e8a35a")}
FACES = {"A": ("#3c6896", "#2b4c70"), "B": ("#93652f", "#6e4a20")} FACES = {"A": ("#3c6896", "#2b4c70"), "B": ("#93652f", "#6e4a20")}
REV_SECONDS = 1.8 # a 33⅓ rpm record: one turn every 1.8 s REV_SECONDS = 1.8 # a 33⅓ rpm record: one turn every 1.8 s
WINDOW_SECONDS = 8.0 # the waveforms show this much, centred WINDOW_SECONDS = 8.0 # the waveforms show this much, centred
ZOOM_OUT = 2.0 # …and this many times more when paused or held
COMPACT_HEIGHT = 200 COMPACT_HEIGHT = 200
DEFAULT_ROWS_BELOW = 15 DEFAULT_ROWS_BELOW = 15
MIN_ROWS_BELOW, MAX_ROWS_BELOW = 5, 28 MIN_ROWS_BELOW, MAX_ROWS_BELOW = 5, 28
GRIP = 8 GRIP = 8
DECK_WIDTH = 250 # a record's column: |◀ ⏯ and "Sync to other track" fit
WARN_GAIN = 0.5 WARN_GAIN = 0.5
@@ -67,6 +69,7 @@ class DeckView:
self.bpm_saved = False self.bpm_saved = False
self.counted = False self.counted = False
self.mult = 1.0 # the ½× / 1× / 2× switch self.mult = 1.0 # the ½× / 1× / 2× switch
self.synced = False # following the other deck's tempo
@property @property
def color(self) -> QColor: def color(self) -> QColor:
@@ -128,9 +131,36 @@ def _check_svg() -> str:
return _CHECK_SVG return _CHECK_SVG
def _deck_button_qss(name: str) -> str: def _start_icon(size=16) -> QPixmap:
"""|◀ : a bar and a left-pointing triangle."""
pix = QPixmap(size, size)
pix.fill(Qt.GlobalColor.transparent)
p = QPainter(pix)
p.setRenderHint(QPainter.RenderHint.Antialiasing)
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(QColor("#f4f4f4"))
s = size / 16
p.drawRect(QRectF(2 * s, 2 * s, 2.2 * s, 12 * s))
path = QPainterPath(QPointF(14 * s, 2 * s))
path.lineTo(5 * s, 8 * s)
path.lineTo(14 * s, 14 * s)
path.closeSubpath()
p.drawPath(path)
p.end()
return pix
def _deck_button_qss(name: str, glow: bool = False) -> str:
top, bottom = FACES[name] top, bottom = FACES[name]
color = COLORS[name].name() color = COLORS[name].name()
if glow:
# Synced: lit in the deck's colour, with a bright rim.
top, bottom = COLORS[name].name(), COLORS[name].darker(140).name()
return (f"QPushButton {{ color: white; font-weight: bold;"
f" border: 2px solid {COLORS[name].lighter(150).name()};"
f" border-radius: 6px; padding: 3px 9px;"
f" background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 {top}, stop:1 {bottom}); }}"
f"QPushButton:pressed {{ background: {COLORS[name].darker(160).name()}; }}")
return (f"QPushButton, QToolButton {{ color: #f4f4f4; border: 1px solid #111;" return (f"QPushButton, QToolButton {{ color: #f4f4f4; border: 1px solid #111;"
f" border-radius: 6px; padding: 4px 10px;" f" border-radius: 6px; padding: 4px 10px;"
f" background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 {top}, stop:1 {bottom}); }}" f" background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 {top}, stop:1 {bottom}); }}"
@@ -371,6 +401,10 @@ class WaveLanes(QWidget):
"it plays what passes the playhead, backwards too") "it plays what passes the playhead, backwards too")
self._drag = None # (view, x, time) self._drag = None # (view, x, time)
self._rate = 0.0 self._rate = 0.0
# Seconds of heard time across each lane: WINDOW_SECONDS while the
# deck plays, zoomed out (×ZOOM_OUT) while it's paused or held —
# easing between the two, as djay does.
self._window = {"A": WINDOW_SECONDS, "B": WINDOW_SECONDS}
self._still = QTimer(self) self._still = QTimer(self)
self._still.setInterval(45) self._still.setInterval(45)
self._still.timeout.connect(self._hand_still) self._still.timeout.connect(self._hand_still)
@@ -402,7 +436,7 @@ class WaveLanes(QWidget):
dx = event.position().x() - x0 dx = event.position().x() - x0
dt = max(1e-3, now - t0) dt = max(1e-3, now - t0)
# dragging right pulls the song back under the playhead # dragging right pulls the song back under the playhead
seconds = -dx / max(1, self.width()) * WINDOW_SECONDS * view.deck.speed seconds = -dx / max(1, self.width()) * self._window[view.name] * view.deck.speed
rate = seconds / dt rate = seconds / dt
self._rate = 0.6 * rate + 0.4 * self._rate self._rate = 0.6 * rate + 0.4 * self._rate
view.deck.scratch_rate = max(-8.0, min(8.0, self._rate)) view.deck.scratch_rate = max(-8.0, min(8.0, self._rate))
@@ -450,8 +484,15 @@ class WaveLanes(QWidget):
w = int(lane.width()) w = int(lane.width())
speed = deck.speed if deck.scratch_rate is None else 1.0 speed = deck.speed if deck.scratch_rate is None else 1.0
heard = self.shelf.heard_seconds(view) heard = self.shelf.heard_seconds(view)
moving = deck.playing and deck.scratch_rate is None
target = WINDOW_SECONDS if moving else WINDOW_SECONDS * ZOOM_OUT
window = self._window[view.name]
window += (target - window) * 0.12
if abs(window - target) < 0.01:
window = target
self._window[view.name] = window
# source seconds at each pixel edge # source seconds at each pixel edge
edges = heard + (np.arange(w + 1) / w - 0.5) * WINDOW_SECONDS * speed edges = heard + (np.arange(w + 1) / w - 0.5) * window * speed
idx = np.clip((edges * analysis.PEAKS_PER_SECOND).astype(np.int64), 0, len(peaks)) idx = np.clip((edges * analysis.PEAKS_PER_SECOND).astype(np.int64), 0, len(peaks))
values = _pixel_max(peaks, idx) values = _pixel_max(peaks, idx)
values[(edges[:-1] < 0) | (edges[:-1] >= len(peaks) / analysis.PEAKS_PER_SECOND)] = 0 values[(edges[:-1] < 0) | (edges[:-1] >= len(peaks) / analysis.PEAKS_PER_SECOND)] = 0
@@ -477,7 +518,7 @@ class WaveLanes(QWidget):
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))
span = WINDOW_SECONDS * speed span = window * speed
for k in range(first, last + 1): for k in range(first, last + 1):
t = view.offset + k * beat t = view.offset + k * beat
x = (t - heard) / span * w + w / 2 x = (t - heard) / span * w + w / 2
@@ -487,6 +528,18 @@ 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))
def _load_horn(horn):
"""The bundled air-horn recording into the mixer's horn (best effort:
no ffmpeg, no horn — the button just stays silent)."""
from importlib import resources
try:
path = resources.files("lintunes") / "sounds" / "airhorn.mp3"
with resources.as_file(path) as real:
horn.set_sample(decode(str(real)))
except Exception: # noqa: BLE001 — a missing horn is no failure
pass
class HornButton(QToolButton): class HornButton(QToolButton):
"""The air horn: it blares for as long as it's held.""" """The air horn: it blares for as long as it's held."""
@@ -503,8 +556,8 @@ class HornButton(QToolButton):
" background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 #5a5c5f, stop:1 #3d3f42); }" " background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 #5a5c5f, stop:1 #3d3f42); }"
"QToolButton:hover { background: #4a4c4f; }" "QToolButton:hover { background: #4a4c4f; }"
"QToolButton:pressed { background: #2a2b2d; }") "QToolButton:pressed { background: #2a2b2d; }")
self.pressed.connect(lambda: setattr(self._horn, "on", True)) self.pressed.connect(self._horn.press)
self.released.connect(lambda: setattr(self._horn, "on", False)) self.released.connect(self._horn.release)
def _horn_icon(w=26, h=18) -> QPixmap: def _horn_icon(w=26, h=18) -> QPixmap:
@@ -529,89 +582,229 @@ def _horn_icon(w=26, h=18) -> QPixmap:
return pix return pix
class Crossfader(QWidget): class SnapSlider(QWidget):
"""The crossfader: a big handle on a slim track, a line at the middle, """A DJ slider: a slim track, a line at its middle, a big handle, and a
and a gentle snap to the middle when the handle is let go close to it. gentle snap — let it go (or drag it) within ``snap`` of the middle and
0..1000, like a QSlider's value; double-click centres it.""" it sits exactly there. Integer ``lo``..``hi`` like a QSlider; a vertical
one runs bottom (``lo``) to top (``hi``). Double-click returns it to
``home``. ``tint`` colours the handle (a deck's colour), None is grey."""
valueChanged = pyqtSignal(int) valueChanged = pyqtSignal(int)
SNAP = 30 # within 3 % of the middle → the middle
HANDLE = QSize(28, 44)
TRACK = 8 TRACK = 8
def __init__(self, parent=None): def __init__(self, vertical: bool, lo: int, hi: int, *, home: int = 0,
snap: int = 0, handle=QSize(28, 44), tint: QColor | None = None,
parent=None):
super().__init__(parent) super().__init__(parent)
self._value = 500 self.vertical = vertical
self.lo, self.hi = lo, hi
self.home = home
self.snap = snap
self.handle = handle
self.tint = tint
self._value = home
self._dragging = False self._dragging = False
self.setFixedHeight(self.HANDLE.height() + 4) self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.setMinimumWidth(160) if vertical:
self.setToolTip("Crossfader (double-click: centre)") self.setFixedWidth(handle.width() + 4)
self.setMinimumHeight(handle.height() * 2)
else:
self.setFixedHeight(handle.height() + 4)
self.setMinimumWidth(handle.width() * 3)
@property
def centre(self) -> float:
return (self.lo + self.hi) / 2
def value(self) -> int: def value(self) -> int:
return self._value return self._value
def setValue(self, value: int): def setValue(self, value: int):
value = max(0, min(1000, int(value))) value = max(self.lo, min(self.hi, int(round(value))))
if value != self._value: if value != self._value:
self._value = value self._value = value
self.valueChanged.emit(value) self.valueChanged.emit(value)
self.update() self.update()
def _span(self) -> tuple[float, float]: def _snapped(self, value: int) -> int:
half = self.HANDLE.width() / 2 if self.snap and abs(value - self.centre) <= self.snap:
return half, self.width() - half return int(self.centre)
return value
def _value_at(self, x: float) -> int: # ---- geometry ----
lo, hi = self._span()
return round((x - lo) / max(1.0, hi - lo) * 1000) def _band(self) -> QRectF:
"""Where the track runs (the widget less anything drawn beside it)."""
return QRectF(self.rect())
def _span(self) -> tuple[float, float]:
band = self._band()
if self.vertical:
half = self.handle.height() / 2
return band.bottom() - half, band.top() + half
half = self.handle.width() / 2
return band.left() + half, band.right() - half
def _pos_of(self, value: float) -> float:
a, b = self._span()
return a + (b - a) * (value - self.lo) / max(1, self.hi - self.lo)
def _value_at(self, point) -> int:
a, b = self._span()
coord = point.y() if self.vertical else point.x()
return round(self.lo + (coord - a) / (b - a or 1) * (self.hi - self.lo))
# ---- mouse ----
def mousePressEvent(self, event): def mousePressEvent(self, event):
if event.button() == Qt.MouseButton.LeftButton: if event.button() == Qt.MouseButton.LeftButton:
self._dragging = True self._dragging = True
self.setValue(self._value_at(event.position().x())) self.setValue(self._snapped(self._value_at(event.position())))
def mouseMoveEvent(self, event): def mouseMoveEvent(self, event):
if self._dragging: if self._dragging:
value = self._value_at(event.position().x()) self.setValue(self._snapped(self._value_at(event.position())))
if abs(value - 500) <= self.SNAP:
value = 500 # a little detent at the middle
self.setValue(value)
def mouseReleaseEvent(self, event): def mouseReleaseEvent(self, event):
self._dragging = False self._dragging = False
if abs(self._value - 500) <= self.SNAP: self.setValue(self._snapped(self._value))
self.setValue(500)
def mouseDoubleClickEvent(self, event): def mouseDoubleClickEvent(self, event):
self.setValue(500) self.setValue(self.home)
# ---- painting ----
def paintEvent(self, event): def paintEvent(self, event):
p = QPainter(self) p = QPainter(self)
p.setRenderHint(QPainter.RenderHint.Antialiasing) p.setRenderHint(QPainter.RenderHint.Antialiasing)
lo, hi = self._span() band = self._band()
mid_y = self.height() / 2 a, b = self._span()
track = QRectF(lo - 4, mid_y - self.TRACK / 2, hi - lo + 8, self.TRACK) t = self.TRACK
if self.vertical:
cx = band.center().x()
track = QRectF(cx - t / 2, min(a, b) - 4, t, abs(b - a) + 8)
else:
cy = band.center().y()
track = QRectF(min(a, b) - 4, cy - t / 2, abs(b - a) + 8, t)
path = QPainterPath() path = QPainterPath()
path.addRoundedRect(track, self.TRACK / 2, self.TRACK / 2) path.addRoundedRect(track, t / 2, t / 2)
p.fillPath(path, QColor("#1b1b1c")) p.fillPath(path, QColor("#1b1b1c"))
# the middle mid = self._pos_of(self.centre)
cx = (lo + hi) / 2
p.setPen(QPen(QColor("#8a8a8a"), 2)) p.setPen(QPen(QColor("#8a8a8a"), 2))
p.drawLine(QPointF(cx, 2), QPointF(cx, self.height() - 2)) if self.vertical:
x = lo + (hi - lo) * self._value / 1000 p.drawLine(QPointF(band.left() + 2, mid), QPointF(band.right() - 2, mid))
handle = QRectF(x - self.HANDLE.width() / 2, mid_y - self.HANDLE.height() / 2, else:
self.HANDLE.width(), self.HANDLE.height()) p.drawLine(QPointF(mid, band.top() + 2), QPointF(mid, band.bottom() - 2))
at = self._pos_of(self._value)
w, h = self.handle.width(), self.handle.height()
if self.vertical:
# a vertical fader's cap lies across the track
w, h = h, w
box = QRectF(band.center().x() - w / 2, at - h / 2, w, h)
else:
box = QRectF(at - w / 2, band.center().y() - h / 2, w, h)
p.setPen(Qt.PenStyle.NoPen) p.setPen(Qt.PenStyle.NoPen)
p.setBrush(QColor(0, 0, 0, 110)) p.setBrush(QColor(0, 0, 0, 110))
p.drawRoundedRect(handle.translated(0, 2), 5, 5) p.drawRoundedRect(box.translated(0, 2), 5, 5)
face = QLinearGradient(handle.topLeft(), handle.bottomLeft()) light = self.tint.lighter(125) if self.tint else QColor("#f2f2f2")
face.setColorAt(0, QColor("#f2f2f2")) dark = self.tint.darker(130) if self.tint else QColor("#b2b2b2")
face.setColorAt(1, QColor("#b2b2b2")) face = QLinearGradient(box.topLeft(), box.bottomLeft())
face.setColorAt(0, light)
face.setColorAt(1, dark)
p.setBrush(QBrush(face)) p.setBrush(QBrush(face))
p.setPen(QPen(QColor("#111"), 1)) p.setPen(QPen(QColor("#111"), 1))
p.drawRoundedRect(handle, 5, 5) p.drawRoundedRect(box, 5, 5)
p.setPen(QPen(QColor("#555"), 2)) p.setPen(QPen(QColor(0, 0, 0, 120), 2))
p.drawLine(QPointF(x, handle.top() + 8), QPointF(x, handle.bottom() - 8)) if self.vertical:
p.drawLine(QPointF(box.left() + 6, at), QPointF(box.right() - 6, at))
else:
p.drawLine(QPointF(at, box.top() + 8), QPointF(at, box.bottom() - 8))
class Crossfader(SnapSlider):
"""The crossfader: 0 (all A) … 1000 (all B), a snap within 3 % of the
middle, a handle twice the old one's height."""
SNAP = 30
HANDLE = QSize(28, 44)
def __init__(self, parent=None):
super().__init__(False, 0, 1000, home=500, snap=self.SNAP,
handle=self.HANDLE, parent=parent)
self.setMinimumWidth(160)
self.setToolTip("Crossfader (double-click: centre)")
def _vocal_icon(kind: str, color: QColor, size: int = 14) -> QPixmap:
"""mic (vocals only), mic + note (both), note (instrumental only)."""
pix = QPixmap(size * 2 if kind == "both" else size, size)
pix.fill(Qt.GlobalColor.transparent)
p = QPainter(pix)
p.setRenderHint(QPainter.RenderHint.Antialiasing)
s = size / 14
def mic(x):
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(color)
p.drawRoundedRect(QRectF(x + 4 * s, 1 * s, 6 * s, 8 * s), 3 * s, 3 * s)
p.setPen(QPen(color, 1.3 * s))
p.setBrush(Qt.BrushStyle.NoBrush)
p.drawArc(QRectF(x + 2.5 * s, 3.5 * s, 9 * s, 8 * s), 200 * 16, 140 * 16)
p.drawLine(QPointF(x + 7 * s, 11.5 * s), QPointF(x + 7 * s, 13 * s))
def note(x):
p.setPen(Qt.PenStyle.NoPen)
p.setBrush(color)
p.drawEllipse(QRectF(x + 2 * s, 9 * s, 5 * s, 4 * s))
p.drawRect(QRectF(x + 6 * s, 1.5 * s, 1.4 * s, 9.5 * s))
flag = QPainterPath(QPointF(x + 7.4 * s, 1.5 * s))
flag.cubicTo(QPointF(x + 10 * s, 3 * s), QPointF(x + 12 * s, 5 * s),
QPointF(x + 10.5 * s, 8 * s))
flag.lineTo(x + 7.4 * s, 4.5 * s)
flag.closeSubpath()
p.drawPath(flag)
if kind == "vocals":
mic(0)
elif kind == "instrumental":
note(0)
else:
mic(0)
note(size)
p.end()
return pix
class VocalSlider(SnapSlider):
"""Vocals only (−100) · both (0) · instrumental only (+100), with its
three icons drawn exactly over the ends and the middle of the travel."""
ICONS = 16
def __init__(self, tint: QColor, parent=None):
super().__init__(False, -100, 100, home=0, snap=8,
handle=QSize(16, 22), tint=tint, parent=parent)
self.setFixedHeight(self.handle.height() + 4 + self.ICONS)
self._icons = None
self.setToolTip("Vocals only · both · instrumental only (double-click: both)")
def _band(self) -> QRectF:
return QRectF(self.rect()).adjusted(0, self.ICONS, 0, 0)
def paintEvent(self, event):
super().paintEvent(event)
enabled = self.isEnabled()
color = QColor("#b8b8b8" if enabled else "#5a5a5a")
if self._icons is None or self._icons[0] != color.name():
self._icons = (color.name(), {k: _vocal_icon(k, color)
for k in ("vocals", "both", "instrumental")})
icons = self._icons[1]
p = QPainter(self)
for kind, value in (("vocals", self.lo), ("both", 0), ("instrumental", self.hi)):
pix = icons[kind]
x = self._pos_of(value) - pix.width() / 2
x = max(0.0, min(self.width() - pix.width(), x))
p.drawPixmap(QPointF(x, 0), pix)
class Grip(QWidget): class Grip(QWidget):
@@ -685,6 +878,7 @@ class DjShelf(QWidget):
self._manager = manager self._manager = manager
self._prefs = prefs self._prefs = prefs
self.mixer = Mixer() self.mixer = Mixer()
_load_horn(self.mixer.horn)
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
# Worker threads report through signals into bound methods, so Qt # Worker threads report through signals into bound methods, so Qt
@@ -713,7 +907,12 @@ class DjShelf(QWidget):
# ---- layout ---- # ---- layout ----
def _build(self): def _build(self):
outer = QVBoxLayout(self) # Everything sits on a body as tall as the shelf is *meant* to be;
# opening and closing only changes how much of it shows, so the
# decks are revealed in place rather than squeezed (Round 94).
self._body = QWidget(self)
self._layout_height = None
outer = QVBoxLayout(self._body)
outer.setContentsMargins(16, 16, 16, 0) outer.setContentsMargins(16, 16, 16, 0)
outer.setSpacing(0) outer.setSpacing(0)
row = QHBoxLayout() row = QHBoxLayout()
@@ -739,6 +938,7 @@ class DjShelf(QWidget):
self.bpm_notes = {} self.bpm_notes = {}
self.pitch_boxes = {} self.pitch_boxes = {}
self.mult_buttons = {} self.mult_buttons = {}
self.start_buttons = {}
self._compact_hidden = [] self._compact_hidden = []
self._big_records = {} self._big_records = {}
@@ -786,20 +986,18 @@ class DjShelf(QWidget):
col.addWidget(fader_title("TEMPO", v), alignment=Qt.AlignmentFlag.AlignHCenter) 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) span = int(SPEED_RANGE * 10000)
slider.setRange(-int(SPEED_RANGE * 10000), int(SPEED_RANGE * 10000)) # a light snap at 0: within 0.3 % it's exactly the song's tempo
slider.setValue(0) slider = SnapSlider(True, -span, span, home=0, snap=30,
slider.setStyleSheet(_slider_qss(v.name, vertical=True)) handle=QSize(20, 30), tint=v.color)
slider.setToolTip(f"Deck {v.name} speed (double-click: back to 0)") slider.setToolTip(f"Deck {v.name} tempo (double-click: back to 0)")
slider.valueChanged.connect(lambda value, v=v: self._on_speed(v, value)) slider.valueChanged.connect(lambda value, v=v: self._on_speed(v, value))
slider.mouseDoubleClickEvent = lambda e, s=slider: s.setValue(0)
label = QLabel("+0.0%") label = QLabel("+0.0%")
label.setStyleSheet(f"color: {v.color.name()}; font-size: 11px;") label.setStyleSheet(f"color: {v.color.name()}; font-size: 11px;")
label.setAlignment(Qt.AlignmentFlag.AlignCenter) label.setAlignment(Qt.AlignmentFlag.AlignCenter)
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(2, 1) col.setStretch(2, 1)
@@ -825,10 +1023,20 @@ class DjShelf(QWidget):
buttons = QHBoxLayout(controls) buttons = QHBoxLayout(controls)
buttons.setContentsMargins(0, 0, 0, 0) buttons.setContentsMargins(0, 0, 0, 0)
buttons.setSpacing(8) buttons.setSpacing(8)
back = QToolButton()
back.setIcon(QIcon(_start_icon()))
back.setIconSize(QSize(16, 16))
back.setFixedSize(34, 34)
back.setToolTip(f"Deck {v.name}: back to the beginning")
back.clicked.connect(lambda _=False, v=v: self.to_start(v))
back.setStyleSheet(_deck_button_qss(v.name))
back.setFocusPolicy(Qt.FocusPolicy.NoFocus)
buttons.addWidget(back)
self.start_buttons[v.name] = back
play = QToolButton() play = QToolButton()
play.setIcon(QIcon(_play_icon(False))) play.setIcon(QIcon(_play_icon(False)))
play.setIconSize(QSize(16, 16)) play.setIconSize(QSize(16, 16))
play.setFixedSize(56, 34) play.setFixedSize(46, 34)
play.setToolTip(f"Play / pause Deck {v.name}") play.setToolTip(f"Play / pause Deck {v.name}")
play.clicked.connect(lambda _=False, v=v: self.toggle(v)) play.clicked.connect(lambda _=False, v=v: self.toggle(v))
sync = QPushButton("Sync to other track") sync = QPushButton("Sync to other track")
@@ -848,20 +1056,8 @@ class DjShelf(QWidget):
vcol = QVBoxLayout(vocals) vcol = QVBoxLayout(vocals)
vcol.setContentsMargins(0, 0, 0, 0) vcol.setContentsMargins(0, 0, 0, 0)
vcol.setSpacing(2) vcol.setSpacing(2)
ends = QHBoxLayout() slider = VocalSlider(v.color)
for text in ("Vocals", "Both", "Instrumental"):
lab = QLabel(text)
lab.setStyleSheet(f"color: {DIM}; font-size: 10px;")
ends.addWidget(lab)
if text != "Instrumental":
ends.addStretch()
vcol.addLayout(ends)
slider = QSlider(Qt.Orientation.Horizontal)
slider.setRange(-100, 100)
slider.setValue(0)
slider.setStyleSheet(_slider_qss(v.name, vertical=False))
slider.valueChanged.connect(lambda value, v=v: setattr(v.deck, "vocal_mix", value / 100)) slider.valueChanged.connect(lambda value, v=v: setattr(v.deck, "vocal_mix", value / 100))
slider.mouseDoubleClickEvent = lambda e, s=slider: s.setValue(0)
vcol.addWidget(slider) vcol.addWidget(slider)
note = QLabel("") note = QLabel("")
note.setStyleSheet(f"color: {DIM}; font-size: 10px;") note.setStyleSheet(f"color: {DIM}; font-size: 10px;")
@@ -870,7 +1066,7 @@ class DjShelf(QWidget):
self.stem_labels[v.name] = note self.stem_labels[v.name] = note
col.addWidget(vocals) col.addWidget(vocals)
self._compact_hidden += [controls, vocals] self._compact_hidden += [controls, vocals]
holder.setFixedWidth(220) holder.setFixedWidth(DECK_WIDTH)
self._big_records[v.name] = holder self._big_records[v.name] = holder
return holder return holder
@@ -994,18 +1190,44 @@ class DjShelf(QWidget):
return box return box
def set_mult(self, view: DeckView, mult: float): def set_mult(self, view: DeckView, mult: float):
changed = mult != view.mult
view.mult = mult view.mult = mult
for b, m in zip(self.mult_buttons[view.name], (0.5, 1.0, 2.0)): for b, m in zip(self.mult_buttons[view.name], (0.5, 1.0, 2.0)):
b.setChecked(m == mult) b.setChecked(m == mult)
self._refresh_deck(view) self._refresh_deck(view)
if changed:
# Counting the beats differently moves where they line up: a
# synced pair re-syncs at once, whichever side follows.
other = self.other(view)
if view.synced:
self.sync(view)
elif other.synced:
self.sync(other)
def resizeEvent(self, event): def set_layout_height(self, height: int | None):
super().resizeEvent(event) """How tall the decks are laid out, whatever height shows (None:
compact = self.height() < COMPACT_HEIGHT as tall as the shelf)."""
self._layout_height = height
self._place_body()
def layout_height(self) -> int:
return self._layout_height or self.height()
def _place_body(self):
height = self.layout_height()
if self._body.geometry() != QRect(0, 0, self.width(), height):
self._body.setGeometry(0, 0, self.width(), height)
compact = height < COMPACT_HEIGHT
if compact != getattr(self, "_compact", None):
self._compact = compact
for w in self._compact_hidden: for w in self._compact_hidden:
w.setVisible(not compact) w.setVisible(not compact)
for holder in self._big_records.values(): for holder in self._big_records.values():
holder.setFixedWidth(max(60, self.height() - 30) if compact else 220) holder.setFixedWidth(max(60, height - 30) if compact else DECK_WIDTH)
def resizeEvent(self, event):
super().resizeEvent(event)
self._place_body()
def paintEvent(self, event): def paintEvent(self, event):
p = QPainter(self) p = QPainter(self)
@@ -1218,6 +1440,12 @@ class DjShelf(QWidget):
target = other.beat_bpm * other.deck.speed target = other.beat_bpm * other.deck.speed
view.deck.speed = analysis.sync_speed(view.beat_bpm, target) view.deck.speed = analysis.sync_speed(view.beat_bpm, target)
self._show_speed(view) self._show_speed(view)
# Sync stays on: this deck follows the other's tempo until its own
# tempo fader is moved. Only one deck follows the other.
view.synced = True
if other.synced:
other.synced = False
self._refresh_deck(other)
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.beat_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.beat_bpm) theirs = analysis.beat_phase(self.heard_seconds(other), other.offset, other.beat_bpm)
@@ -1233,6 +1461,28 @@ class DjShelf(QWidget):
if getattr(self, "_setting_speed", False): if getattr(self, "_setting_speed", False):
return return
view.deck.speed = 1.0 + value / 10000.0 view.deck.speed = 1.0 + value / 10000.0
view.synced = False # taken out of sync by hand
self._refresh_deck(view)
def _follow(self, view: DeckView):
"""A synced deck keeps the other's tempo as that one changes."""
other = self.other(view)
if not view.synced or not view.beat_bpm or not other.beat_bpm:
return
speed = analysis.sync_speed(view.beat_bpm, other.beat_bpm * other.deck.speed)
if abs(speed - view.deck.speed) > 1e-5:
view.deck.speed = speed
self._show_speed(view)
self._refresh_deck(view)
def to_start(self, view: DeckView):
"""|◀: back to the very beginning of the song."""
deck = view.deck
if deck.source is None:
return
deck.seek(0)
deck.ended = False
view.counted = False
self._refresh_deck(view) self._refresh_deck(view)
def _show_speed(self, view: DeckView): def _show_speed(self, view: DeckView):
@@ -1271,7 +1521,9 @@ class DjShelf(QWidget):
self.bpm_labels[view.name].setText(f"{view.beat_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 ""
self.bpm_notes[view.name].setText(f"BPM · original {view.beat_bpm:.1f}{change}") counted = {0.5: " · counted ½×", 2.0: " · counted 2×"}.get(view.mult, "")
self.bpm_notes[view.name].setText(
f"BPM{counted} · original {view.beat_bpm:.1f}{change}")
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")
@@ -1279,9 +1531,13 @@ class DjShelf(QWidget):
self.play_buttons[view.name].setIcon(QIcon(_play_icon(deck.playing))) self.play_buttons[view.name].setIcon(QIcon(_play_icon(deck.playing)))
loaded = deck.source is not None loaded = deck.source is not None
self.play_buttons[view.name].setEnabled(loaded) self.play_buttons[view.name].setEnabled(loaded)
self.start_buttons[view.name].setEnabled(loaded)
# Always clickable once this deck has a song: whatever sync can't do # Always clickable once this deck has a song: whatever sync can't do
# yet (an empty other deck, a tempo still being worked out) it says. # yet (an empty other deck, a tempo still being worked out) it says.
self.sync_buttons[view.name].setEnabled(loaded) self.sync_buttons[view.name].setEnabled(loaded)
sync = self.sync_buttons[view.name]
sync.setText("Synced" if view.synced else "Sync to other track")
sync.setStyleSheet(_deck_button_qss(view.name, glow=view.synced))
self._refresh_note(view) self._refresh_note(view)
def _tick(self): def _tick(self):
@@ -1295,6 +1551,8 @@ class DjShelf(QWidget):
if viz is not None and sounding != self._sounding: if viz is not None and sounding != self._sounding:
viz.dj_playing_changed() viz.dj_playing_changed()
self._sounding = sounding self._sounding = sounding
for v in self.views:
self._follow(v)
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:
+9 -4
View File
@@ -448,7 +448,7 @@ class MainWindow(QMainWindow):
self._add_action(file_menu, "New Smart Playlist", "Ctrl+Alt+N", self._add_action(file_menu, "New Smart Playlist", "Ctrl+Alt+N",
lambda: self._sidebar.tree.create_smart_playlist_interactive()) lambda: self._sidebar.tree.create_smart_playlist_interactive())
self._add_action(file_menu, "New Playlist Folder", "Ctrl+Shift+N", self._add_action(file_menu, "New Playlist Folder", "Ctrl+Shift+N",
lambda: self._manager.create_folder("untitled folder")) lambda: self._sidebar.tree.create_folder_interactive())
file_menu.addSeparator() file_menu.addSeparator()
self._add_action(file_menu, "Add Files to Library…", "Ctrl+O", self._add_action(file_menu, "Add Files to Library…", "Ctrl+O",
self._open_files_dialog) self._open_files_dialog)
@@ -2398,6 +2398,7 @@ class MainWindow(QMainWindow):
self._transport.set_dj_mode(True, self._dj_titles()) self._transport.set_dj_mode(True, self._dj_titles())
track_table.deck_tag = self._deck_tag track_table.deck_tag = self._deck_tag
shelf.set_master(self._dj_master()) shelf.set_master(self._dj_master())
shelf.set_layout_height(target) # laid out full size, revealed
shelf.setFixedHeight(0) shelf.setFixedHeight(0)
shelf.show() shelf.show()
shelf.start() shelf.start()
@@ -2407,6 +2408,7 @@ class MainWindow(QMainWindow):
else: else:
shelf = self._dj shelf = self._dj
track_table.deck_tag = None track_table.deck_tag = None
shelf.set_layout_height(shelf.height()) # covered, not squeezed
self._animate_shelf(shelf.height(), 0, done=self._dj_closed) self._animate_shelf(shelf.height(), 0, done=self._dj_closed)
self._refresh_tables() self._refresh_tables()
@@ -2487,7 +2489,9 @@ class MainWindow(QMainWindow):
if self._dj_resize_from is None: if self._dj_resize_from is None:
self._dj_resize_from = self._dj.height() self._dj_resize_from = self._dj.height()
low, high = self._dj_bounds() low, high = self._dj_bounds()
self._dj.setFixedHeight(max(low, min(high, self._dj_resize_from + dy))) height = max(low, min(high, self._dj_resize_from + dy))
self._dj.set_layout_height(height)
self._dj.setFixedHeight(height)
def _on_dj_resize_done(self): def _on_dj_resize_done(self):
self._dj_resize_from = None self._dj_resize_from = None
@@ -2502,8 +2506,9 @@ class MainWindow(QMainWindow):
config = load_config() config = load_config()
config.pop("dj_shelf_height", None) config.pop("dj_shelf_height", None)
save_config(config) save_config(config)
self._animate_shelf(self._dj.height(), target = max(low, min(high, default_height(viewport, row)))
max(low, min(high, default_height(viewport, row)))) self._dj.set_layout_height(target)
self._animate_shelf(self._dj.height(), target)
def _deck_tag(self, track_id: int): def _deck_tag(self, track_id: int):
if self._dj is None: if self._dj is None:
+4
View File
@@ -548,6 +548,10 @@ class PreferencesDialog(QDialog):
bars = QWidget() bars = QWidget()
form = self._viz_form(bars) form = self._viz_form(bars)
self._preset_row(form, "bars") self._preset_row(form, "bars")
self._bars_count_box = self._viz_spinbox(
form, "Bars:", "visualizer_bars_count", config, step=1, decimals=0,
suffix="", tip="How many bars, 1 to 1024. Past the drawing's width "
"it's one bar per pixel, SoundJam style")
self._bars_fade_slider, _ = self._viz_slider( self._bars_fade_slider, _ = self._viz_slider(
form, "Fade:", "visualizer_bars_fade", config, scale=20, form, "Fade:", "visualizer_bars_fade", config, scale=20,
fmt=_fade_text, tip=fade_tip) fmt=_fade_text, tip=fade_tip)
+17 -5
View File
@@ -1,6 +1,6 @@
from PyQt6.QtWidgets import ( from PyQt6.QtWidgets import (
QWidget, QVBoxLayout, QPushButton, QTreeWidget, QTreeWidgetItem, QMenu, QWidget, QVBoxLayout, QPushButton, QTreeWidget, QTreeWidgetItem, QMenu,
QInputDialog, QMessageBox, QAbstractItemView, QLineEdit, QApplication, QMessageBox, QAbstractItemView, QLineEdit, QApplication,
QHBoxLayout, QListWidget, QListWidgetItem, QStackedWidget, QSizePolicy, QHBoxLayout, QListWidget, QListWidgetItem, QStackedWidget, QSizePolicy,
QFrame, QFrame,
) )
@@ -761,6 +761,21 @@ class PlaylistTree(QTreeWidget):
self._select_all_next_edit = True self._select_all_next_edit = True
self.editItem(item, 0) # live inline rename; editor selects all self.editItem(item, 0) # live inline rename; editor selects all
def create_folder_interactive(self, parent_pid: str = ""):
"""Create a folder, scroll to it and open its name for editing,
all selected: type and it's named (Enter commits, Escape keeps
"untitled folder") — the same as a new playlist (Round 94)."""
folder = self._manager.create_folder("untitled folder", parent_pid)
item = self._find_item(folder.persistent_id)
if item is not None:
parent = item.parent()
if parent is not None:
parent.setExpanded(True)
self.scrollToItem(item, QAbstractItemView.ScrollHint.EnsureVisible)
self.setCurrentItem(item)
self._select_all_next_edit = True
self.editItem(item, 0)
def create_smart_playlist_interactive(self, parent_pid: str = ""): def create_smart_playlist_interactive(self, parent_pid: str = ""):
"""Open the criteria editor; on accept, create the smart playlist and """Open the criteria editor; on accept, create the smart playlist and
drop into inline rename (mirrors create_playlist_interactive).""" drop into inline rename (mirrors create_playlist_interactive)."""
@@ -871,10 +886,7 @@ class PlaylistTree(QTreeWidget):
elif edit_smart is not None and chosen is edit_smart: elif edit_smart is not None and chosen is edit_smart:
self.edit_smart_playlist(pid) self.edit_smart_playlist(pid)
elif chosen is new_folder: elif chosen is new_folder:
name, ok = QInputDialog.getText(self, "New Playlist Folder", "Name:", self.create_folder_interactive(parent_pid)
text="untitled folder")
if ok and name.strip():
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: elif dj_prepare is not None and chosen is dj_prepare:
+29 -25
View File
@@ -488,6 +488,7 @@ class TransportBar(QWidget):
# between the visualizer and the timeline. The HBox centers it # between the visualizer and the timeline. The HBox centers it
# vertically, so nothing stacks above or below it (iTunes-style). # vertically, so nothing stacks above or below it (iTunes-style).
self._volume_slider = ClickJumpSlider() self._volume_slider = ClickJumpSlider()
self._volume_slider.setProperty("tall", True) # the scrubber's height
self._volume_slider.setRange(0, 100) self._volume_slider.setRange(0, 100)
self._volume_slider.setFixedWidth(96) self._volume_slider.setFixedWidth(96)
# As tall as the boxes, so its groove (drawn centered) sits on the # As tall as the boxes, so its groove (drawn centered) sits on the
@@ -573,18 +574,28 @@ class TransportBar(QWidget):
self._now_playing.installEventFilter(self) self._now_playing.installEventFilter(self)
gap() gap()
# bpm tap button lives on the far right as its own box, top-aligned # DJ mode's button is the far-right box (Round 94: it swapped with
# with the now-playing panel like the transport boxes — kept out of # bpm, so it stays put while the window parts under it); the bpm
# the seek row so it doesn't drive the timeline row's height. # tap button sits under it, in the header row.
self._bpm_button = BpmButton(player, manager) self.dj_button = QToolButton()
# The whole box is the tap target, so it darkens (and taps) as one. self.dj_button.setObjectName("djButton")
bpm_box = _box(self._bpm_button, bg=box_bg, margins=(3, 3, 3, 3), self.dj_button.setCheckable(True)
self.dj_button.setToolTip("DJ mode")
self.dj_button.setIcon(turntable_icon(QColor(ICON_GRAY), 22))
self.dj_button.setIconSize(QSize(30, 22))
self.dj_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.dj_button.setFixedWidth(52)
self.dj_button.toggled.connect(self._on_dj_button)
dj_box = _box(self.dj_button, bg=box_bg, margins=(3, 3, 3, 3),
hug=True, height=CONTROL_HEIGHT, split=True) hug=True, height=CONTROL_HEIGHT, split=True)
self._boxes.append(bpm_box) self._boxes.append(dj_box)
layout.addWidget(bpm_box, alignment=TOP) layout.addWidget(dj_box, alignment=TOP)
self._fixed_controls = (transport_box, shuffle_box, repeat_box, self._fixed_controls = (transport_box, shuffle_box, repeat_box,
self._visualizer, self._visualizer,
self._volume_slider, bpm_box) self._volume_slider, dj_box)
self._bpm_button = BpmButton(player, manager)
self._bpm_button.setObjectName("bpmHeader")
self._bpm_button.setFlat(False)
# Library button · the current view's header · seek row. MainWindow # Library button · the current view's header · seek row. MainWindow
# hands over the first two (see set_sidebar_header / set_view_header) # hands over the first two (see set_sidebar_header / set_view_header)
@@ -594,16 +605,7 @@ class TransportBar(QWidget):
self.set_header_height(34) self.set_header_height(34)
outer.addWidget(self._header_row) outer.addWidget(self._header_row)
# DJ mode's button: under the bpm box, in the header row. self._dj_box = dj_box
self.dj_button = QToolButton()
self.dj_button.setObjectName("djButton")
self.dj_button.setCheckable(True)
self.dj_button.setToolTip("DJ mode")
self.dj_button.setIcon(turntable_icon(QColor(ICON_GRAY)))
self.dj_button.setIconSize(QSize(24, 18))
self.dj_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
self.dj_button.toggled.connect(self._on_dj_button)
self._dj_bpm_box = bpm_box
self._apply_dj_button_style() self._apply_dj_button_style()
self._split_widgets: tuple = () self._split_widgets: tuple = ()
@@ -631,10 +633,12 @@ class TransportBar(QWidget):
# ---- DJ mode ---- # ---- DJ mode ----
def _apply_dj_button_style(self): def _apply_dj_button_style(self):
"""The bpm button under the DJ box wears the shared face (radius 8);
the DJ button is styled by its box like shuffle and repeat."""
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._bpm_button.setStyleSheet(theme.button_face_qss(
"QToolButton#djButton", bg, radius=8, extra="padding: 0;", "QPushButton#bpmHeader", bg, radius=8,
checked_color=bg.darker(theme.CHECKED_DARKER))) extra="padding: 0; color: black;"))
def _on_dj_button(self, on: bool): def _on_dj_button(self, on: bool):
self._on_dj_button_icon(on) self._on_dj_button_icon(on)
@@ -668,7 +672,7 @@ class TransportBar(QWidget):
def _on_dj_button_icon(self, on: bool): def _on_dj_button_icon(self, on: bool):
color = self.palette().highlight().color() if on else QColor(ICON_GRAY) color = self.palette().highlight().color() if on else QColor(ICON_GRAY)
self.dj_button.setIcon(turntable_icon(color)) self.dj_button.setIcon(turntable_icon(color, 22))
def volume_level(self) -> float: def volume_level(self) -> float:
"""The volume slider, 0..1 (perceptual, as Player takes it).""" """The volume slider, 0..1 (perceptual, as Player takes it)."""
@@ -769,8 +773,8 @@ class TransportBar(QWidget):
row.set_panel(QRect(x_of(self._now_playing), 0, row.set_panel(QRect(x_of(self._now_playing), 0,
self._now_playing.width(), row.height())) self._now_playing.width(), row.height()))
box = self._dj_bpm_box box = self._dj_box
row.set_right(self.dj_button, QRect(x_of(box), 0, box.width(), row.height())) row.set_right(self._bpm_button, QRect(x_of(box), 0, box.width(), row.height()))
if self._split_widgets: if self._split_widgets:
lists, content = self._split_widgets lists, content = self._split_widgets
row.set_split(x_of(lists), x_of(lists, lists.width()), row.set_split(x_of(lists), x_of(lists, lists.width()),
+1 -1
View File
@@ -24,7 +24,7 @@ PRESETS_KEY = "visualizer_presets"
DEFAULT_NAME = "Default" DEFAULT_NAME = "Default"
STYLE_KEYS = { STYLE_KEYS = {
"bars": ("visualizer_bars_fade",), "bars": ("visualizer_bars_fade", "visualizer_bars_count"),
"radial": ("visualizer_ghost_fade", "visualizer_radial_spokes", "radial": ("visualizer_ghost_fade", "visualizer_radial_spokes",
"visualizer_radial_levels", "visualizer_radial_dot", "visualizer_radial_levels", "visualizer_radial_dot",
"visualizer_radial_normalize"), "visualizer_radial_normalize"),
+41 -16
View File
@@ -55,6 +55,9 @@ HISTORY = RADIAL_FFT # samples the widget keeps for the FFTs
# use the same numbers, so a hand-edited file can't go past what they offer. # use the same numbers, so a hand-edited file can't go past what they offer.
LIMITS = { LIMITS = {
"visualizer_bars_fade": (0.0, 3.0), # seconds; 0 = off "visualizer_bars_fade": (0.0, 3.0), # seconds; 0 = off
# SoundJam's look at the top: one bar per pixel. Past the drawing's
# width bars are merged pixel by pixel, so a big number costs nothing.
"visualizer_bars_count": (1, 1024),
"visualizer_ghost_fade": (0.0, 3.0), "visualizer_ghost_fade": (0.0, 3.0),
"visualizer_laser_afterimage": (0.0, 3.0), "visualizer_laser_afterimage": (0.0, 3.0),
"visualizer_laser_width": (1.0, 8.0), # pixels "visualizer_laser_width": (1.0, 8.0), # pixels
@@ -73,6 +76,7 @@ LIMITS = {
_FLAGS = ("visualizer_radial_normalize", "visualizer_laser_head", _FLAGS = ("visualizer_radial_normalize", "visualizer_laser_head",
"visualizer_laser_glow", "visualizer_laser_grid") "visualizer_laser_glow", "visualizer_laser_grid")
_INTEGER = ("visualizer_radial_spokes", "visualizer_radial_levels", _INTEGER = ("visualizer_radial_spokes", "visualizer_radial_levels",
"visualizer_bars_count",
"visualizer_laser_low_hz", "visualizer_laser_high_hz") "visualizer_laser_low_hz", "visualizer_laser_high_hz")
SPEAKER_MIN_RATIO = 2 ** (1 / 3) # the narrowest speaker: a third-octave SPEAKER_MIN_RATIO = 2 ** (1 / 3) # the narrowest speaker: a third-octave
@@ -225,28 +229,39 @@ def _faded(color: QColor, alpha: float) -> QColor:
# -------------------------------------------------------------------------- # --------------------------------------------------------------------------
class BarsRenderer: class BarsRenderer:
"""The 20-band graphic EQ. With a fade time, the steps a falling bar """The graphic EQ: ``visualizer_bars_count`` log-spaced bands (20 by
leaves behind fade from its color into the background, rather than default, 1 to 1024). With a fade time, the steps a falling bar leaves
vanishing — the radial's ghosts, as blocks.""" behind fade from its color into the background, rather than vanishing —
the radial's ghosts, as blocks. More bars than pixels are drawn one per
pixel column (each the loudest of the bars it covers); past ~40 bars the
FFT doubles to 4096 points so the narrow bass bands have bins to read."""
name = STYLE_BARS name = STYLE_BARS
def __init__(self, config=None): def __init__(self, config=None):
self.levels = np.zeros(BANDS) self.count = BANDS
self.bars = [0] * BANDS # quantized 0..STEPS self._size(BANDS)
# (band, step) → when the bar last fell past it; -inf = never.
self.ghosts = np.full((BANDS, STEPS + 1), -np.inf)
self.clock = 0.0 self.clock = 0.0
self.configure(config or settings(None)) self.configure(config or settings(None))
def _size(self, count: int):
self.count = count
self.levels = np.zeros(count)
self.bars = [0] * count # quantized 0..STEPS
# (band, step) → when the bar last fell past it; -inf = never.
self.ghosts = np.full((count, STEPS + 1), -np.inf)
def configure(self, config): def configure(self, config):
self.fade = config["visualizer_bars_fade"] self.fade = config["visualizer_bars_fade"]
count = int(config.get("visualizer_bars_count", BANDS))
if count != self.count:
self._size(count)
if self.fade <= 0: if self.fade <= 0:
self.ghosts[:] = -np.inf self.ghosts[:] = -np.inf
def clear(self): def clear(self):
self.levels[:] = 0.0 self.levels[:] = 0.0
self.bars = [0] * BANDS self.bars = [0] * self.count
self.ghosts[:] = -np.inf self.ghosts[:] = -np.inf
def ghost_alpha(self) -> np.ndarray: def ghost_alpha(self) -> np.ndarray:
@@ -256,11 +271,12 @@ class BarsRenderer:
def advance(self, frame: Frame) -> bool: def advance(self, frame: Frame) -> bool:
self.clock += frame.dt self.clock += frame.dt
spectrum, freqs = spectrum_of(frame.samples, BARS_FFT, frame.rate) fft = BARS_FFT if self.count <= 40 else RADIAL_FFT
new_levels = band_levels(spectrum, freqs, band_edges(BANDS, frame.rate)) spectrum, freqs = spectrum_of(frame.samples, fft, frame.rate)
new_levels = band_levels(spectrum, freqs, band_edges(self.count, frame.rate))
# Instant attack, slow decay # Instant attack, slow decay
self.levels = np.maximum(new_levels, self.levels * DECAY) self.levels = np.maximum(new_levels, self.levels * DECAY)
bars = [int(round(level * STEPS)) for level in self.levels] bars = np.rint(self.levels * STEPS).astype(int).tolist()
if self.fade > 0: if self.fade > 0:
old, new = np.array(self.bars), np.array(bars) old, new = np.array(self.bars), np.array(bars)
k = np.arange(STEPS + 1)[None, :] k = np.arange(STEPS + 1)[None, :]
@@ -279,26 +295,35 @@ class BarsRenderer:
avail_h = rect.height() - 2 * INSET avail_h = rect.height() - 2 * INSET
left = int(rect.x()) + INSET left = int(rect.x()) + INSET
baseline = int(rect.y() + rect.height()) - INSET baseline = int(rect.y() + rect.height()) - INSET
bar_width = avail_w / BANDS
step_height = avail_h / STEPS step_height = avail_h / STEPS
bars = np.asarray(self.bars)
alpha = self.ghost_alpha()
columns = self.count
if columns > avail_w >= 1:
# More bars than pixels: one per pixel, the loudest it covers.
columns = int(avail_w)
starts = (np.arange(columns) * self.count / columns).astype(int)
bars = np.maximum.reduceat(bars, starts)
alpha = np.maximum.reduceat(alpha, starts, axis=0) if alpha.size else alpha
bar_width = avail_w / max(1, columns)
gap_px = 1 if bar_width >= 3 else 0 # thin bars touch
def column(i): def column(i):
x = left + int(i * bar_width) x = left + int(i * bar_width)
end = left + int((i + 1) * bar_width) end = left + int((i + 1) * bar_width)
gap = 1 if i < BANDS - 1 else 0 # 1px between bars, none at edge gap = gap_px if i < columns - 1 else 0
return x, max(1, end - x - gap) return x, max(1, end - x - gap)
alpha = self.ghost_alpha()
if alpha.any(): if alpha.any():
for i, k in zip(*np.nonzero(alpha)): for i, k in zip(*np.nonzero(alpha)):
if k <= self.bars[i]: if k <= bars[i]:
continue # under the bar itself continue # under the bar itself
x, w = column(i) x, w = column(i)
top = baseline - int(k * step_height) top = baseline - int(k * step_height)
bottom = baseline - int((k - 1) * step_height) bottom = baseline - int((k - 1) * step_height)
painter.fillRect(x, top, w, bottom - top, painter.fillRect(x, top, w, bottom - top,
_faded(color, GHOST_ALPHA * alpha[i, k])) _faded(color, GHOST_ALPHA * alpha[i, k]))
for i, bar in enumerate(self.bars): for i, bar in enumerate(bars.tolist()):
if bar <= 0: if bar <= 0:
continue continue
x, w = column(i) x, w = column(i)
+1
View File
@@ -19,6 +19,7 @@ DEFAULTS = {
# Fade times in seconds, 0 = off: how long what a bar or dot left # Fade times in seconds, 0 = off: how long what a bar or dot left
# behind, or the laser's past sweeps, take to fade into the background. # behind, or the laser's past sweeps, take to fade into the background.
"visualizer_bars_fade": 0.0, "visualizer_bars_fade": 0.0,
"visualizer_bars_count": 20, # 1 … 1024 (one per pixel, at most)
"visualizer_ghost_fade": 1.0, # the radial's "visualizer_ghost_fade": 1.0, # the radial's
"visualizer_laser_afterimage": 0.1, "visualizer_laser_afterimage": 0.1,
"visualizer_laser_width": 1.5, # pixels "visualizer_laser_width": 1.5, # pixels
+7
View File
@@ -0,0 +1,7 @@
# Sound credits
- `tink.wav` — LinTunes' own.
- `airhorn.mp3` — "Air Horn Hype" by zar.265 on Freesound
(https://freesound.org/people/zar.265/sounds/581334/), released under
Creative Commons 0 (public domain). The DJ shelf's air horn plays its
first blast, sustained for as long as the button is held.
Binary file not shown.
+1 -1
View File
@@ -17,7 +17,7 @@ setup(
# The andTunes APK LinTunes installs, and the default button artwork # The andTunes APK LinTunes installs, and the default button artwork
# sync ships to the device. # sync ships to the device.
package_data={ package_data={
"lintunes": ["sounds/*.wav"], "lintunes": ["sounds/*.wav", "sounds/*.mp3", "sounds/*.md"],
"lintunes.export": ["templates/*"], "lintunes.export": ["templates/*"],
"lintunes.android": ["andTunes.apk", "andTunes.json"], "lintunes.android": ["andTunes.apk", "andTunes.json"],
"lintunes.andtunes": ["buttons/*.png"], "lintunes.andtunes": ["buttons/*.png"],
+1 -1
View File
@@ -16,7 +16,7 @@ def test_every_control_shares_the_now_playing_row(qapp, tmp_path):
assert panel.height() == CONTROL_HEIGHT assert panel.height() == CONTROL_HEIGHT
for widget in (bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(), for widget in (bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(),
bar._visualizer, bar._volume_slider, bar._visualizer, bar._volume_slider,
bar._bpm_button.parentWidget()): bar.dj_button.parentWidget()):
g = widget.geometry() g = widget.geometry()
assert (g.top(), g.bottom()) == (panel.top(), panel.bottom()) assert (g.top(), g.bottom()) == (panel.top(), panel.bottom())
+2 -2
View File
@@ -125,7 +125,7 @@ def test_panel_fills_what_the_gaps_leave(qapp, tmp_path):
window.resize(bar.minimumSizeHint().width() + 16, 500) window.resize(bar.minimumSizeHint().width() + 16, 500)
qapp.processEvents() qapp.processEvents()
assert bar._now_playing.width() >= NOW_PLAYING_MIN assert bar._now_playing.width() >= NOW_PLAYING_MIN
bpm = bar._bpm_button.parentWidget() bpm = bar.dj_button.parentWidget()
assert bar._now_playing.geometry().right() < bpm.geometry().left() assert bar._now_playing.geometry().right() < bpm.geometry().left()
assert bpm.geometry().right() < bar.width() assert bpm.geometry().right() < bar.width()
@@ -166,7 +166,7 @@ def test_row_is_knolled_with_equal_gaps_and_ends(qapp, tmp_path):
qapp.processEvents() qapp.processEvents()
row = [bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(), row = [bar._prev_btn.parentWidget(), bar._shuffle_btn.parentWidget(),
bar._repeat_btn.parentWidget(), bar._visualizer, bar._volume_slider, bar._now_playing, bar._repeat_btn.parentWidget(), bar._visualizer, bar._volume_slider, bar._now_playing,
bar._bpm_button.parentWidget()] bar.dj_button.parentWidget()]
edges = [(w.geometry().left(), w.geometry().right()) for w in row] edges = [(w.geometry().left(), w.geometry().right()) for w in row]
gaps = [b[0] - a[1] - 1 for a, b in zip(edges, edges[1:])] gaps = [b[0] - a[1] - 1 for a, b in zip(edges, edges[1:])]
# The same GAP everywhere, ends included, at every width. # The same GAP everywhere, ends included, at every width.
+2 -1
View File
@@ -963,7 +963,8 @@ class TestPresets:
def test_a_preset_only_holds_its_own_style(self, qapp, tmp_path): def test_a_preset_only_holds_its_own_style(self, qapp, tmp_path):
prefs = Preferences(tmp_path) prefs = Preferences(tmp_path)
presets.save(prefs, "bars", "x") presets.save(prefs, "bars", "x")
assert set(presets.presets(prefs, "bars")["x"]) == {"visualizer_bars_fade"} assert set(presets.presets(prefs, "bars")["x"]) == {"visualizer_bars_fade",
"visualizer_bars_count"}
assert "visualizer_sync_delay_ms" not in presets.STYLE_KEYS["laser"] assert "visualizer_sync_delay_ms" not in presets.STYLE_KEYS["laser"]
def test_an_old_preset_takes_new_settings_defaults(self, qapp, tmp_path): def test_an_old_preset_takes_new_settings_defaults(self, qapp, tmp_path):
+7 -5
View File
@@ -78,13 +78,15 @@ def test_deck_volume_and_horn():
mixer.crossfader = 0.0 mixer.crossfader = 0.0
mixer.a.volume = 0.5 mixer.a.volume = 0.5
assert mixer.deck_gain(mixer.a) == pytest.approx(0.5) assert mixer.deck_gain(mixer.a) == pytest.approx(0.5)
mixer.horn.on = True tone = (np.sin(np.arange(RATE) / RATE * 2 * np.pi * 400) * 20000).astype(np.int16)
mixer.horn.set_sample(np.stack([tone, tone], axis=1)) # a 1 s "horn"
mixer.horn.press()
loud = mixer.render(4410) loud = mixer.render(4410)
assert np.abs(loud).max() > 0.1 assert np.abs(loud).max() > 0.1
mixer.horn.on = False mixer.horn.release()
mixer.render(RATE // 2) mixer.render(RATE)
assert mixer.horn.render(64) is None # it has died away assert mixer.horn.render(64) is None # it has played out
assert len(mixer.tap) == 2 and mixer.rendered == 4410 + RATE // 2 assert len(mixer.tap) == 2 and mixer.rendered == 4410 + RATE
def test_the_visualizer_draws_the_mix(shelf, qapp): def test_the_visualizer_draws_the_mix(shelf, qapp):
+215
View File
@@ -0,0 +1,215 @@
"""Round 95: DJ mode, round three — the shelf revealed in place, the DJ
button where bpm was, snapping sliders (tempo, vocals, crossfader), sticky
sync that glows and re-syncs on ½×/2×, back to the start, the real air
horn, zoom-out when paused or held, a sink that follows the system's output
— and outside DJ mode: a new folder named in place, the bars' count, a
taller volume slider."""
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.audio import RATE, Horn
from tests.test_round93 import _clicks, _loaded, shelf # noqa: F401 — the fixture
def _mouse(kind, x, y):
return QMouseEvent(kind, QPointF(x, y), QPointF(x, y), Qt.MouseButton.LeftButton,
Qt.MouseButton.LeftButton, Qt.KeyboardModifier.NoModifier)
class TestSnapSlider:
def test_vertical_tempo_snaps_to_zero(self, qapp):
from lintunes.gui.dj_shelf import SnapSlider
slider = SnapSlider(True, -800, 800, snap=30)
slider.resize(slider.width(), 400)
a, b = slider._span() # bottom, top
y_near = a + (b - a) * (830 / 1600) # +30 → snaps
slider.mousePressEvent(_mouse(QEvent.Type.MouseButtonPress, 10, y_near))
assert slider.value() == 0
slider.mouseMoveEvent(_mouse(QEvent.Type.MouseMove, 10, b))
assert slider.value() == 800 # top is +8 %
slider.mouseReleaseEvent(_mouse(QEvent.Type.MouseButtonRelease, 10, b))
slider.mouseDoubleClickEvent(None)
assert slider.value() == 0
def test_vocals_icons_sit_on_the_ends_and_middle(self, qapp):
from PyQt6.QtGui import QColor
from lintunes.gui.dj_shelf import VocalSlider
slider = VocalSlider(QColor("#5a9be0"))
slider.resize(220, slider.height())
lo, hi = slider._span()
assert slider._pos_of(-100) == pytest.approx(lo)
assert slider._pos_of(0) == pytest.approx((lo + hi) / 2)
assert slider._pos_of(100) == pytest.approx(hi)
slider.setValue(5)
slider.mouseReleaseEvent(None)
assert slider.value() == 0 # within the snap
class TestSync:
def _pair(self, shelf):
a, b = shelf.views
_loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.15, 20), 124.0, 0.15)
_loaded(shelf, b, shelf.tracks[1], _clicks(118, 0.05, 20), 118.0, 0.05)
return a, b
def test_sync_sticks_glows_and_follows(self, shelf):
a, b = self._pair(shelf)
shelf.sync(b)
assert b.synced and shelf.sync_buttons["B"].text() == "Synced"
shelf.speed["A"].setValue(200) # A +2 %: B follows
shelf._tick()
assert b.deck.speed == pytest.approx(124 * 1.02 / 118)
shelf.speed["B"].setValue(0) # B moved by hand: unsynced
assert not b.synced
assert shelf.sync_buttons["B"].text() == "Sync to other track"
def test_only_one_deck_follows(self, shelf):
a, b = self._pair(shelf)
shelf.sync(b)
shelf.sync(a)
assert a.synced and not b.synced
def test_half_time_resyncs_a_playing_pair(self, shelf):
a, b = self._pair(shelf)
a.deck.playing = b.deck.playing = True
a.deck.position, b.deck.position = RATE * 3.0, RATE * 7.31
shelf.sync(b)
before = b.deck.position
shelf.set_mult(b, 0.5)
assert "counted ½×" in shelf.bpm_notes["B"].text()
assert b.synced and b.deck.speed == pytest.approx(124 / 118)
assert b.deck.position != before # re-lined up on the new grid
def test_back_to_the_start(self, shelf):
a, _ = self._pair(shelf)
a.deck.seek(RATE * 5)
a.deck.ended = True
shelf.to_start(a)
assert a.deck.position == 0 and not a.deck.ended
class TestHorn:
def _horn(self):
x = (np.sin(np.arange(RATE * 2) / RATE * 2 * np.pi * 400) * 20000).astype(np.int16)
return Horn(np.stack([x, x], axis=1))
def _drain(self, horn):
total = 0
while True:
block = horn.render(4096)
if block is None:
return total / RATE
total += len(block)
def test_a_tap_plays_the_whole_recording(self):
horn = self._horn()
horn.press()
horn.render(441)
horn.release()
assert 0.01 + self._drain(horn) == pytest.approx(2.0, abs=0.1)
def test_holding_stretches_it(self):
horn = self._horn()
horn.press()
held = sum(len(horn.render(4096)) for _ in range(int(4 * RATE / 4096))) / RATE
horn.release()
assert held > 3.9
assert self._drain(horn) <= 2.0 # then the rest plays out
def test_the_bundled_recording_loads(self, qapp):
from lintunes.gui.dj_shelf import _load_horn
horn = Horn()
_load_horn(horn)
assert horn._src is not None and len(horn._src) > RATE
def test_the_waveform_zooms_out_while_paused(shelf):
a, _ = shelf.views
_loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 10), 124.0, 0.1)
lanes = shelf.lanes
lanes.resize(600, 120)
for _ in range(80):
lanes.grab() # paused: eases out
assert lanes._window["A"] == pytest.approx(16.0)
a.deck.playing = True
for _ in range(80):
lanes.grab()
assert lanes._window["A"] == pytest.approx(8.0)
def test_revealed_in_place(shelf):
shelf.set_layout_height(330)
shelf.setFixedHeight(40) # mid-animation
assert shelf._body.height() == 330
assert shelf.sync_buttons["A"].isVisibleTo(shelf) # laid out full, not compact
def test_the_sink_follows_the_default_output(monkeypatch):
from lintunes.dj import output
pump = output._Pump(MagicMock())
opened = []
pump._open = lambda: opened.append(1) or True
pump.sink = MagicMock()
pump.sink.error.return_value = output.QAudio.Error.NoError
pump.io = MagicMock()
pump.device_id = b"old"
other = MagicMock()
other.isNull.return_value = False
other.id.return_value = b"new"
monkeypatch.setattr(output.QMediaDevices, "defaultAudioOutput", lambda: other)
pump._fill()
assert opened == [1]
def test_bars_count_and_one_per_pixel(qapp):
from PyQt6.QtCore import QRectF
from PyQt6.QtGui import QColor, QImage, QPainter
from lintunes.gui.visualizer_styles import BarsRenderer, Frame, settings
config = settings(None)
config["visualizer_bars_count"] = 1024
renderer = BarsRenderer(config)
x = (np.random.default_rng(1).standard_normal(4096) * 0.3).astype(np.float32)
renderer.advance(Frame(x, 44100, x[:735], 1 / 60))
assert len(renderer.bars) == 1024
image = QImage(206, 60, QImage.Format.Format_RGB32)
image.fill(QColor("black"))
painter = QPainter(image)
renderer.paint(painter, QRectF(0, 0, 206, 60), QColor("white"))
painter.end()
renderer.configure(dict(config, visualizer_bars_count=1))
assert len(renderer.bars) == 1
def test_new_folder_is_named_in_place(qapp, tmp_path):
from lintunes.gui.sidebar import PlaylistTree
from lintunes.library_manager import LibraryManager
from lintunes.models.library import Library
manager = LibraryManager(Library(), tmp_path)
tree = PlaylistTree(manager)
tree.show()
tree.create_folder_interactive()
item = tree.currentItem()
assert item is not None and item.text(0) == "untitled folder"
assert tree.state() == tree.State.EditingState
tree.close()
def test_dj_button_up_top_bpm_below_and_a_tall_volume(qapp, tmp_path):
import tempfile
from pathlib import Path
from lintunes.gui.transport import TransportBar
from lintunes.preferences import Preferences
player = MagicMock()
player.repeat_mode.return_value = "off"
with tempfile.TemporaryDirectory() as d:
bar = TransportBar(player, MagicMock(), Preferences(Path(d)))
assert bar.dj_button.parentWidget() is bar._dj_box
assert bar._dj_box in bar._fixed_controls
bar._place_header() # what a resize does
assert bar._header_row.right is bar._bpm_button
assert bar._volume_slider.property("tall") is True