Skip to content

A modern and easy to use dashboard. 80+ integrations. 20K+ icons built in. Authentication out of the box. No YAML, drag and drop configuration.

6.3 KB
Raw Blame
"""Procedural instruments and effects for the reel soundtrack (128 BPM). score.py arranges them."""
import numpy as np
from scipy import signal
from scipy.io import wavfile

SR = 48000
BPM = 128
BEAT = 60 / BPM
BAR = 4 * BEAT
E8 = BEAT / 2
S16 = BEAT / 4
rng = np.random.default_rng(7)

def tt(d):
    return np.arange(int(d * SR)) / SR


def noise(d):
    return rng.standard_normal(int(d * SR))


def mtof(m):
    return 440.0 * 2 ** ((m - 69) / 12)


NOTE = {n: i for i, n in enumerate(['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'])}


def nf(name):  # 'A4' -> Hz
    return mtof(12 * (int(name[-1]) + 1) + NOTE[name[:-1]])


def sos(kind, f, order=2):
    return signal.butter(order, f, kind, fs=SR, output='sos')


def lp(x, f, order=2):
    return signal.sosfilt(sos('low', f, order), x, axis=0)


def hp(x, f, order=2):
    return signal.sosfilt(sos('high', f, order), x, axis=0)


def bp(x, lo, hi, order=2):
    return signal.sosfilt(signal.butter(order, [lo, hi], 'band', fs=SR, output='sos'), x, axis=0)


def tv_biquad(x, fc, q=1.0, kind='bp', block=64):
    """Time-varying RBJ biquad; fc is an array (Hz) the length of x."""
    y = np.zeros_like(x)
    zi = np.zeros(2)
    for i in range(0, len(x), block):
        f = float(np.clip(fc[min(i + block // 2, len(fc) - 1)], 20, SR * 0.45))
        w0 = 2 * np.pi * f / SR
        al = np.sin(w0) / (2 * q)
        c = np.cos(w0)
        if kind == 'bp':
            b = [al, 0, -al]
        elif kind == 'lp':
            b = [(1 - c) / 2, 1 - c, (1 - c) / 2]
        else:
            b = [(1 + c) / 2, -(1 + c), (1 + c) / 2]
        a = [1 + al, -2 * c, 1 - al]
        y[i:i + block], zi = signal.lfilter(np.array(b) / a[0], np.array(a) / a[0], x[i:i + block], zi=zi)
    return y


def saw(freq, d, maxh=40, phase=0.0):
    t = tt(d)
    out = np.zeros_like(t)
    K = int(min(maxh, (SR / 2 - 200) // freq))
    for k in range(1, K + 1):
        out += np.sin(2 * np.pi * k * freq * t + phase * k) / k
    return out * (2 / np.pi)


def adsr(d, a=0.005, r=0.05, tau=None):
    t = tt(d)
    e = np.minimum(1, t / max(a, 1e-4))
    if tau:
        e = e * np.exp(-t / tau)
    rel = np.clip((d - t) / r, 0, 1)
    return e * rel


# ─────────────────────────── instruments ───────────────────────────
def kick(d=0.45):
    t = tt(d)
    f = 46 + (190 - 46) * np.exp(-t / 0.026)
    body = np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-t / 0.26)
    ck = hp(noise(0.012), 2500) * np.exp(-tt(0.012) / 0.0025) * 0.5
    body[:len(ck)] += ck
    return np.tanh(body * 1.8) * 0.85


def clap(d=0.4):
    t = tt(d)
    n = bp(noise(d), 900, 3200)
    env = np.zeros_like(t)
    for o in (0, 0.010, 0.021):
        env += np.where(t >= o, np.exp(-(t - o) / 0.007), 0)
    env += np.where(t >= 0.028, np.exp(-(t - 0.028) / 0.11), 0) * 0.7
    return n * env * 0.45


def snare(d=0.25):
    t = tt(d)
    tone = np.sin(2 * np.pi * (190 + 60 * np.exp(-t / 0.02)) * t) * np.exp(-t / 0.06)
    n = bp(noise(d), 1500, 9000) * np.exp(-t / 0.09)
    return (tone * 0.5 + n * 0.6) * 0.6


def hat(d=0.08, open_=False):
    n = hp(noise(d), 7500, 4)
    return n * np.exp(-tt(d) / (0.11 if open_ else 0.02)) * 0.22


def bass(freq, d):
    t = tt(d)
    s = saw(freq, d, 24) * 0.55 + np.sin(2 * np.pi * freq * t) * 0.9
    s = lp(s, 420)
    return np.tanh(s * adsr(d, 0.004, 0.03, 0.5) * 1.4) * 0.7


def pad(freqs, d, cutoff=1700, a=0.12, r=0.35):
    L = np.zeros(int(d * SR))
    R = np.zeros(int(d * SR))
    for f in freqs:
        for k, det in enumerate((-9, -3, 4, 10)):
            s = saw(f * 2 ** (det / 1200), d, 30, phase=rng.uniform(0, 6))
            (L if k % 2 == 0 else R)[:] += s
    st = np.stack([L, R], 1) / (len(freqs) * 2)
    st = lp(st, cutoff)
    return st * adsr(d, a, r)[:, None]


def pluck(freq, d=0.5, bright=1.0):
    t = tt(d)
    out = np.zeros_like(t)
    K = int(min(16, (SR / 2 - 500) // freq))
    for k in range(1, K + 1):
        out += np.sin(2 * np.pi * k * freq * t) / k * np.exp(-t * (4 + k * 7 / bright))
    return out * np.minimum(1, t / 0.002) * 0.5


def bell(freq, d=1.2):
    t = tt(d)
    out = sum(a * np.sin(2 * np.pi * freq * r * t) * np.exp(-t / dcy) for r, a, dcy in
              ((1, 1, 0.9), (2.0, 0.45, 0.5), (3.01, 0.25, 0.3), (4.2, 0.15, 0.18), (5.43, 0.08, 0.1)))
    return out * np.minimum(1, t / 0.002) * 0.35


def impact(d=2.2, big=1.0):
    t = tt(d)
    f = 28 + (95 - 28) * np.exp(-t / 0.22)
    boom = np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-t / (0.55 * big))
    nz = lp(noise(d), 2200) * np.exp(-t / 0.22) * 0.55
    crack = hp(noise(d), 2500) * np.exp(-t / 0.045) * 0.5
    return np.tanh((boom * 1.3 + nz + crack) * 1.4) * 0.9


def crash(d=1.6):
    t = tt(d)
    n = lp(hp(noise(d), 4500, 3), 12000) * np.exp(-t / 0.42)
    n2 = lp(hp(noise(d), 4500, 3), 12000) * np.exp(-t / 0.42)
    return np.stack([n, n2], 1) * 0.11


def whoosh(d, f0, f1, q=1.4, curve=2.0, pan0=0.0, pan1=0.0, peak=0.5):
    t = tt(d)
    x = t / d
    fc = f0 * (f1 / f0) ** x
    n = tv_biquad(noise(d), fc, q, 'bp')
    env = np.where(x < peak, (x / peak) ** curve, ((1 - x) / (1 - peak)) ** 1.5)
    s = n * env
    pan = pan0 + (pan1 - pan0) * x
    th = (pan + 1) * np.pi / 4
    return np.stack([s * np.cos(th), s * np.sin(th)], 1) * np.sqrt(2) * 0.9


def riser(d, f0=250, f1=2400):
    t = tt(d)
    x = t / d
    fc = f0 * (f1 / f0) ** x
    n = tv_biquad(noise(d), fc * 3, 2.5, 'bp')
    tone = np.sin(2 * np.pi * np.cumsum(fc) / SR) * 0.25
    env = x ** 2.2
    return (n * 0.7 + tone) * env


def revcym(d):
    x = tt(d) / d
    n = hp(noise(d), 3500, 3)
    return np.stack([n, hp(noise(d), 3500, 3)], 1) * (x ** 3)[:, None] * 0.35


def click(freq=3200, d=0.03, tau=0.005):
    t = tt(d)
    return (np.sin(2 * np.pi * freq * t) * np.exp(-t / tau) + hp(noise(d), 4000) * np.exp(-t / 0.0015) * 0.4) * 0.6


def pop(f0=380, f1=950, d=0.12):
    t = tt(d)
    f = f0 + (f1 - f0) * (1 - np.exp(-t / 0.02))
    return np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-t / 0.04) * 0.6


def thud(d=0.3):
    t = tt(d)
    f = 55 + 110 * np.exp(-t / 0.03)
    return (np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-t / 0.09) + lp(noise(d), 900) * np.exp(-t / 0.03) * 0.3) * 0.8


def glide(f0, f1, d):
    t = tt(d)
    f = f0 * (f1 / f0) ** (t / d)
    return np.sin(2 * np.pi * np.cumsum(f) / SR) * adsr(d, 0.02, 0.1) * 0.3