diff --git a/CLAUDE.md b/CLAUDE.md index c9ee27b..373956f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -417,7 +417,7 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal "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`; Round 98 below). The zoomed lanes ease out ×2 + (`sounds/airhorn.mp3`, see `sounds/CREDITS.md`; Round 99 below). 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. @@ -432,20 +432,20 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal both waveforms. **Sync sets once** (trav's call): it puts this deck at the other's tempo and stays lit only while that holds (`_check_sync`: same song on the other deck, tempos still equal) — nothing follows anything. - **The horn** (Round 98, the fourth go — the first three failed on the - *recording*, not the code: "Air Horn Hype" is a two-note phrase whose - pitch wanders 9 %, so any loop of it is a beat and any click a - "bee-doop"). Now `sounds/airhorn.mp3` is guitarguy1985's steady can - (359–361 Hz for 7 s, CC0). Held, it simply plays on and laps - `Horn.LOOP` (1.0–7.3 s) through a 0.3 s equal-power crossfade baked into - the sample; a press is a fresh blast from `ONSET` and cuts any still - sounding in 25 ms; a release, after at least `MIN_BLAST` 0.5 s, fades - over `RELEASE` 0.3 s while the read rate falls to `BEND` 0.94 — the - "-ew" (a click ≈ 0.8 s). `render` works in pieces that stop at each - state change. test_round98 holds it to numbers (pitch within 2 % for - 12 s held and after taps, no seam step bigger than the recording's own). - **Before swapping the recording, measure its pitch track** — a steady - sample is the whole design. + **The horn** (Round 99, the fifth go — trav chose the sound: the + classic rap horn from instantrapairhorn.com, `sounds/airhorn.mp3`). It is + one blast: a swoop ~420 → 305 Hz in its first 0.35 s, then 302 Hz steady + to 1.62 s, then its own short end. A click plays the whole recording + untouched, as that page does. Held, it laps `Horn.LOOP` (0.729–1.450 s) + through a 0.2 s crossfade baked into a copy (`_laps`); the steady part is + beating reeds, not a repeating wave (seams correlate ~0.3 at best), so + the crossfade is equal loudness *for the measured correlation*. Let go + before a lap, it plays out; after one, it jumps (40 ms, matched to the + nearest wave cycle) to the loop end, so the ending follows at once. A + press cuts a blast still sounding in 25 ms. test_round99 holds it to the + recording's own loudness range. **Before changing the recording, measure + its pitch and loudness track** — Rounds 93–98 failed on the recording, + not the code. **Loops** (Round 97, djay's Quantize behaviour): a loop starts on the *nearest* beat (it may be just behind — playback carries on inside it); under a beat, it snaps to its own grid; resizing keeps the start and diff --git a/lintunes/__init__.py b/lintunes/__init__.py index 8802ebc..82a0cc2 100644 --- a/lintunes/__init__.py +++ b/lintunes/__init__.py @@ -1,3 +1,3 @@ """LinTunes — iTunes-style music library manager and player for Linux.""" -__version__ = "0.67.1" +__version__ = "0.67.2" diff --git a/lintunes/dj/audio.py b/lintunes/dj/audio.py index f7d04c5..ca6f699 100644 --- a/lintunes/dj/audio.py +++ b/lintunes/dj/audio.py @@ -261,34 +261,31 @@ def crossfade_gains(x: float) -> tuple[float, float]: class Horn: - """The air horn: one continuous tone for as long as it's held. + """The air horn: the classic rap horn, one continuous blast. - The recording ("airhorn.wav" by guitarguy1985, CC0 — - lintunes/sounds/CREDITS.md) is a real canned horn: a quarter-second - swell gliding down into the note, then one steady tone (359–361 Hz, - within 0.5 %) for seven seconds. Measured, because the one before it - ("Air Horn Hype", Rounds 93–97) was a two-note phrase that wobbled 9 % - — no amount of looping could make it hold a tone. + The recording (``sounds/airhorn.mp3``, trav's pick — see + lintunes/sounds/CREDITS.md) is one blast: a swoop from ~420 Hz down to + ~305 Hz over its first 0.35 s ("BWAAA"), then one steady tone (302 Hz, + within 1 %) until 1.62 s and a short natural end. - - **press**: a fresh blast from its attack; one still sounding is cut - in ``CUT`` (rapid taps stay separate blasts). - - **held**: the recording plays on; past ``LOOP``'s end it laps back to - its start, a long equal-power crossfade apart — inaudible on a tone - this steady. - - **release**: after at least ``MIN_BLAST`` (a click is a real blast, - not a blip), the tone falls ``BEND`` in pitch while fading over - ``RELEASE`` — a can running out of air: the "-ew" of "bweeeew". + - **click**: the whole recording, as on the web page it came from. + - **held**: past ``LOOP``'s end it laps back to its start through a + ``XFADE`` crossfade. The steady part is reeds beating, not a + repeating wave (seams correlate ~0.3 at best), so the crossfade is + equal *loudness* for that correlation, measured in ``set_sample``. + - **release**: a blast that never lapped plays out naturally; one that + did jumps (``JUMP``, matched to the nearest wave cycle) to the loop + end, so the recording's own ending follows at once. + - **press** again: a fresh blast; one still sounding is cut in ``CUT``. """ - ONSET = 0.04 # s: where the swell starts in the file - LOOP = (1.0, 7.3) # s: the steady stretch it laps within - XFADE = 0.30 # s: the lap's crossfade - MIN_BLAST = 0.50 # s: what a click always gets - RELEASE = 0.30 # s: the fade on letting go… - BEND = 0.94 # …while the pitch falls to this (~1 semitone) + ONSET = 0.14 # s: just before the blast starts in the file + LOOP = (0.729, 1.450) # s: the steady stretch it laps within + XFADE = 0.20 # s: the lap's crossfade + JUMP = 0.04 # s: release → the ending CUT = 0.025 VOICES = 4 - LEVEL = 0.9 + LEVEL = 1.0 def __init__(self, sample: np.ndarray | None = None): self.on = False @@ -302,69 +299,99 @@ class Horn: src = sample.astype(np.float32) if sample.dtype == np.int16: src /= 32768.0 - peak = float(np.abs(src).max()) or 1.0 + src /= float(np.abs(src).max()) or 1.0 n = len(src) a, b = (min(n - 1, int(t * RATE)) for t in self.LOOP) - if b - a < RATE // 2: # some other, shorter sound: lap its middle + if b - a < RATE // 4: # some other, shorter sound: lap its middle a, b = n // 4, n - n // 20 - xf = min(int(self.XFADE * RATE), max(1, (b - a) // 2)) - # The lap's seam baked in: the stretch's last xf frames fade from - # themselves into what comes before its start, so b → a lands on a - # continuation (equal power — the tone is steady, so they agree). - looped = src.copy() - if a >= xf: + xf = min(int(self.XFADE * RATE), (b - a) // 2, a) + # The lap's seam, baked into a copy: the stretch's last xf frames + # fade from themselves into what comes before its start, so b → a + # lands on a continuation. Scaled for the two sides' correlation, + # so the seam is neither a dip nor a swell. + laps = src.copy() + if xf > 0: + tail, head = src[b - xf:b], src[a - xf:a] + corr = float((tail * head).sum() + / (np.sqrt((tail * tail).sum() * (head * head).sum()) or 1.0)) t = np.linspace(0, 1, xf, dtype=np.float32)[:, None] - looped[b - xf:b] = (src[b - xf:b] * np.cos(t * np.pi / 2) - + src[a - xf:a] * np.sin(t * np.pi / 2)) - self._src = looped / peak - self._loop = (a, b) + fo, fi = np.cos(t * np.pi / 2), np.sin(t * np.pi / 2) + laps[b - xf:b] = (tail * fo + head * fi) / np.sqrt(1 + 2 * corr * fo * fi) + self._src, self._laps, self._loop = src, laps, (a, b) + self._onset = min(int(self.ONSET * RATE), a) # ---- the button ---- def press(self): self.on = True for voice in self._voices: - if voice["state"] == "ending": # cut from where its fade is - k = voice["fade"] / max(1, int(self.RELEASE * RATE)) - voice["gain"] = float(np.cos(k * np.pi / 2) ** 2) if voice["state"] != "cut": - voice["state"] = "cut" - voice["fade"] = 0 - self._voices.append({"state": "held", "pos": float(int(self.ONSET * RATE)), - "started": 0, "gain": 1.0, "rate": 1.0, "fade": 0}) + voice.update(state="cut", fade=0) + self._voices.append({"state": "held", "pos": self._onset, + "lapped": False, "fade": 0}) del self._voices[:-self.VOICES] def release(self): self.on = False + if self._src is None: + return + a, b = self._loop + xf = min(int(self.XFADE * RATE), (b - a) // 2, a) for voice in self._voices: - if voice["state"] == "held": - voice["state"] = "releasing" + if voice["state"] != "held": + continue + if voice["lapped"]: + voice.update(state="jump", fade=0, to=self._match(voice["pos"], b)) + elif voice["pos"] >= b - xf: # mid-seam: back onto the original + voice.update(state="jump", fade=0, to=voice["pos"]) + else: + voice["state"] = "free" + + def _match(self, pos: int, near: int) -> int: + """Where around ``near`` the original best continues what the + held voice is playing at ``pos`` (within one wave cycle).""" + win = int(self.JUMP * RATE) + here = self._laps[pos:pos + win, 0] + best, at = -2.0, near + for to in range(max(0, near - 160), min(len(self._src) - win, near + 160)): + there = self._src[to:to + win, 0] + c = float((here * there).sum()) + if c > best: + best, at = c, to + return at # ---- sound ---- - def _read(self, pos: float, rates: np.ndarray) -> tuple[np.ndarray, float]: - """Frames from ``pos`` at the given per-frame rates (1 = as - recorded), lapping within the loop; linear interpolation.""" - a, b = self._loop - steps = pos + np.concatenate([[0.0], np.cumsum(rates[:-1])]) - if b > a: - over = steps >= b - steps[over] = a + (steps[over] - a) % (b - a) - i0 = np.minimum(steps.astype(np.int64), len(self._src) - 2) - frac = (steps - i0)[:, None].astype(np.float32) - frames = self._src[i0] * (1 - frac) + self._src[i0 + 1] * frac - end = steps[-1] + rates[-1] - if b > a and end >= b: - end = a + (end - a) % (b - a) - return frames, float(end) + def _read(self, voice: dict, n: int, source: np.ndarray) -> np.ndarray: + """n frames from the voice's position; a held voice laps.""" + pos = voice["pos"] + if voice["state"] == "held": + a, b = self._loop + out = np.empty((n, CHANNELS), np.float32) + done = 0 + while done < n: + take = min(n - done, b - pos) + out[done:done + take] = source[pos:pos + take] + done += take + pos += take + if pos >= b: + pos = a + voice["lapped"] = True + voice["pos"] = pos + return out + frames = source[pos:pos + n] + voice["pos"] = pos + len(frames) + if len(frames) < n: + frames = np.concatenate([frames, np.zeros((n - len(frames), CHANNELS), np.float32)]) + return frames def render(self, count: int) -> np.ndarray | None: if self._src is None or not self._voices: return None out = np.zeros((count, CHANNELS), np.float32) - min_blast = int(self.MIN_BLAST * RATE) - release = int(self.RELEASE * RATE) cut = max(1, int(self.CUT * RATE)) + jump = max(1, int(self.JUMP * RATE)) + end = len(self._src) kept = [] for voice in self._voices: done = 0 @@ -372,30 +399,36 @@ class Horn: while done < count and alive: room = count - done state = voice["state"] - if state == "releasing" and voice["started"] >= min_blast: - state = voice["state"] = "ending" - if state in ("held", "releasing"): - n = room if state == "held" else max(1, min(room, min_blast - voice["started"])) - frames, voice["pos"] = self._read(voice["pos"], np.ones(n)) - out[done:done + n] += frames - voice["started"] += n - elif state == "cut": + if state == "held": + n = room + out[done:] += self._read(voice, n, self._laps) + elif state == "free": + n = min(room, end - voice["pos"]) + out[done:done + n] += self._read(voice, n, self._src) + alive = voice["pos"] < end + elif state == "jump": # held sound out, the ending in + n = min(room, jump - voice["fade"]) + k = (voice["fade"] + np.arange(n)) / jump + old = self._laps[voice["pos"]:voice["pos"] + n] + new = self._src[voice["to"]:voice["to"] + n] + m = min(len(old), len(new)) + out[done:done + m] += (old[:m] * np.cos(k[:m, None] * np.pi / 2) + + new[:m] * np.sin(k[:m, None] * np.pi / 2)) + voice["pos"] += n + voice["to"] += n + voice["fade"] += n + if voice["fade"] >= jump: + voice.update(state="free", pos=voice["to"]) + if m < n: + alive = False + else: # cut n = min(room, cut - voice["fade"]) - frames, voice["pos"] = self._read(voice["pos"], np.ones(n)) + pos = min(voice["pos"], end - n) k = voice["fade"] + np.arange(1, n + 1) - gain = voice["gain"] * np.clip(1 - k / cut, 0, 1) - out[done:done + n] += frames * gain[:, None] + out[done:done + n] += self._laps[pos:pos + n] * np.clip(1 - k / cut, 0, 1)[:, None] + voice["pos"] = pos + n voice["fade"] += n alive = voice["fade"] < cut - else: # ending: fade out while the pitch falls - n = min(room, release - voice["fade"]) - k = (voice["fade"] + np.arange(n)) / release - rates = 1.0 - (1.0 - self.BEND) * k - frames, voice["pos"] = self._read(voice["pos"], rates) - gain = np.cos(k * np.pi / 2) ** 2 - out[done:done + n] += frames * gain[:, None] - voice["fade"] += n - alive = voice["fade"] < release done += n if alive: kept.append(voice) diff --git a/lintunes/sounds/CREDITS.md b/lintunes/sounds/CREDITS.md index db00973..1991b85 100644 --- a/lintunes/sounds/CREDITS.md +++ b/lintunes/sounds/CREDITS.md @@ -1,10 +1,10 @@ # Sound credits - `tink.wav` — LinTunes' own. -- `airhorn.mp3` — "airhorn.wav" by guitarguy1985 on Freesound - (https://freesound.org/people/guitarguy1985/sounds/64476/), released - under Creative Commons 0 (public domain). Trimmed to its attack and its - steady blast (0.40–8.00 s of the original). The DJ shelf's air horn - plays it for as long as the button is held. -- (Round 93–97 used "Air Horn Hype" by zar.265, also CC0 — but it is a - two-note phrase that wobbles, so it could never hold one tone.) +- `airhorn.mp3` — the classic rap air horn as played by + https://www.instantrapairhorn.com/, added by trav as-is (1.72 s, 22 kHz + mp3). Its licence isn't stated there. +- Earlier horns, both CC0 from Freesound and both dropped: "Air Horn Hype" + by zar.265 (Rounds 93–97, a wobbling two-note phrase) and "airhorn.wav" + by guitarguy1985 (Round 98, a steady can that didn't sound like the + rap horn). diff --git a/lintunes/sounds/airhorn.mp3 b/lintunes/sounds/airhorn.mp3 index 9a990e5..87ba5bd 100644 Binary files a/lintunes/sounds/airhorn.mp3 and b/lintunes/sounds/airhorn.mp3 differ diff --git a/tests/test_round98.py b/tests/test_round98.py deleted file mode 100644 index c3fa6c3..0000000 --- a/tests/test_round98.py +++ /dev/null @@ -1,72 +0,0 @@ -"""Round 98: the air horn is one continuous tone. A steady recording -(guitarguy1985, CC0) replaces the two-note "Hype" one; held, it plays on -and laps a long crossfade; a click is a real blast; letting go bends the -pitch down as it fades ("bweeeew"); taps are separate blasts.""" - -import numpy as np -import pytest - -from lintunes.dj.audio import RATE, Horn -from lintunes.dj.loader import decode -from tests.test_round97 import _envelope, _play - - -@pytest.fixture(scope="module") -def recording(): - from importlib import resources - with resources.as_file(resources.files("lintunes") / "sounds" / "airhorn.mp3") as path: - return decode(str(path)) - - -def _pitches(x, start, stop, window=4096): - """The strongest frequency (250–450 Hz) in each window.""" - found = [] - for i in range(int(start * RATE), int(stop * RATE) - window, window // 2): - spectrum = np.abs(np.fft.rfft(x[i:i + window] * np.hanning(window), window * 8)) - freqs = np.fft.rfftfreq(window * 8, 1 / RATE) - band = (freqs > 250) & (freqs < 450) - found.append(freqs[band][spectrum[band].argmax()]) - return np.array(found) - - -class TestHorn: - def test_a_held_horn_is_one_tone_past_the_recording(self, recording): - x, horn = _play(recording, [("press", 12.0), ("release", 0.0)]) - pitch = _pitches(x, 0.4, 11.9) - assert pitch.max() / pitch.min() < 1.02 # one note - held = _envelope(x, 0.05)[int(0.4 * RATE):int(11.9 * RATE)] - assert held.min() / held.max() > 0.5 # never drops out - source = recording.astype(np.float32).mean(axis=1) / 32768 - own_step = np.abs(np.diff(source)).max() / np.abs(source).max() - assert np.abs(np.diff(x)).max() <= own_step * horn.LEVEL + 1e-3 # no seam clicks - assert not horn._voices - - def test_a_click_is_a_real_blast_that_bends_down(self, recording): - x, _ = _play(recording, [("press", 0.05), ("release", 0.0)]) - assert 0.7 < len(x) / RATE < 0.9 - pitch = _pitches(x, 0.1, 0.45) - assert pitch.max() / pitch.min() < 1.03 # no "bee-doop" - assert _pitches(x, 0.6, 0.75).mean() < pitch.mean() * 0.98 # the "-ew" - env = _envelope(x) - assert env[-int(0.02 * RATE):].max() < 0.05 * env.max() - - def test_taps_then_a_hold_carry_one_tone(self, recording): - x, horn = _play(recording, [("press", 0.06), ("release", 0.12)] * 6 - + [("press", 4.0), ("release", 0.0)]) - start = 6 * 0.18 + 0.4 - pitch = _pitches(x, start, start + 3.4) - assert pitch.max() / pitch.min() < 1.02 - held = _envelope(x, 0.05)[int(start * RATE):int((start + 3.4) * RATE)] - assert held.min() / held.max() > 0.5 - assert not horn._voices - - def test_a_retrigger_cuts_the_old_blast_quickly(self, recording): - horn = Horn(recording) - horn.press() - horn.render(4410) - horn.release() - horn.render(RATE // 2) # now fading out - horn.press() - assert [v["state"] for v in horn._voices] == ["cut", "held"] - horn.render(int(0.03 * RATE)) - assert [v["state"] for v in horn._voices] == ["held"] diff --git a/tests/test_round99.py b/tests/test_round99.py new file mode 100644 index 0000000..1b8eca9 --- /dev/null +++ b/tests/test_round99.py @@ -0,0 +1,86 @@ +"""Round 99: the classic rap air horn (trav's recording, from +instantrapairhorn.com). A click plays the whole blast as that page does; +held, it laps its steady stretch at the recording's own loudness; let go +after a lap, it goes straight to the recording's own ending; taps are +separate blasts. (Round 98's steady-can recording and its tests are gone.)""" + +import numpy as np +import pytest + +from lintunes.dj.audio import RATE, Horn +from lintunes.dj.loader import decode +from tests.test_round97 import _play + + +@pytest.fixture(scope="module") +def recording(): + from importlib import resources + with resources.as_file(resources.files("lintunes") / "sounds" / "airhorn.mp3") as path: + return decode(str(path)) + + +def _loudness(x, start, stop, window=0.05): + w = int(window * RATE) + return np.array([np.sqrt((x[i:i + w] ** 2).mean()) + for i in range(int(start * RATE), int(stop * RATE) - w, w)]) + + +def _pitches(x, start, stop, window=4096): + """The fundamental (250–350 Hz) in each window.""" + found = [] + for i in range(int(start * RATE), int(stop * RATE) - window, window // 2): + spectrum = np.abs(np.fft.rfft(x[i:i + window] * np.hanning(window), window * 8)) + freqs = np.fft.rfftfreq(window * 8, 1 / RATE) + band = (freqs > 250) & (freqs < 350) + found.append(freqs[band][spectrum[band].argmax()]) + return np.array(found) + + +def _own(horn): + """The recording's steady stretch: its own loudness range.""" + a, b = (t / RATE for t in horn._loop) + return _loudness(horn._src.mean(axis=1), a, b) + + +class TestHorn: + def test_a_click_plays_the_whole_blast_untouched(self, recording): + x, horn = _play(recording, [("press", 0.01), ("release", 0.0)]) + whole = horn._src[horn._onset:].mean(axis=1) + assert len(x) >= len(whole) + np.testing.assert_allclose(x[:len(whole)], whole, atol=1e-6) + assert not horn._voices + + def test_a_hold_is_one_steady_blast_then_its_own_ending(self, recording): + x, horn = _play(recording, [("press", 6.0), ("release", 0.0)]) + own = _own(horn) + held = _loudness(x, 0.7, 5.9) + assert held.min() > 0.9 * own.min() and held.max() < 1.1 * own.max() + pitch = _pitches(x, 0.7, 5.9) + assert pitch.max() / pitch.min() < 1.03 # one note + assert len(x) / RATE < 6.0 + 0.4 # ends at once + source = horn._src.mean(axis=1) + assert np.abs(np.diff(x)).max() <= np.abs(np.diff(source)).max() + 0.02 + + def test_letting_go_before_a_lap_plays_out_naturally(self, recording): + x, horn = _play(recording, [("press", 0.8), ("release", 0.0)]) + whole = horn._src[horn._onset:].mean(axis=1) + np.testing.assert_allclose(x[:len(whole)], whole, atol=1e-6) + + def test_taps_then_a_hold_carry_one_blast(self, recording): + x, horn = _play(recording, [("press", 0.06), ("release", 0.12)] * 6 + + [("press", 4.0), ("release", 0.0)]) + start = 6 * 0.18 + 0.6 + held = _loudness(x, start, start + 3.3) + own = _own(horn) + assert held.min() > 0.9 * own.min() and held.max() < 1.1 * own.max() + assert not horn._voices + + def test_a_retrigger_cuts_the_old_blast_quickly(self, recording): + horn = Horn(recording) + horn.press() + horn.render(4410) + horn.release() + horn.press() + assert [v["state"] for v in horn._voices] == ["cut", "held"] + horn.render(int(0.03 * RATE)) + assert [v["state"] for v in horn._voices] == ["held"]