mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-05 05:52:05 +00:00
142 lines
5.2 KiB
SQL
142 lines
5.2 KiB
SQL
set allow_experimental_analyzer = 1;
|
|
|
|
WITH
|
|
-- Input
|
|
44100 AS sample_frequency
|
|
, number AS tick
|
|
, tick / sample_frequency AS time
|
|
|
|
-- Delay
|
|
, (time, wave, delay_, decay, count) -> arraySum(n1 -> wave(time - delay_ * n1), range(count)) AS delay
|
|
|
|
, delay(time, (time -> 0.5), 0.2, 0.5, 5) AS kick
|
|
|
|
SELECT
|
|
|
|
kick
|
|
|
|
FROM system.numbers
|
|
LIMIT 5;
|
|
|
|
WITH
|
|
-- Input
|
|
44100 AS sample_frequency
|
|
, number AS tick
|
|
, tick / sample_frequency AS time
|
|
|
|
-- Output control
|
|
, 1 AS master_volume
|
|
, level -> least(1.0, greatest(-1.0, level)) AS clamp
|
|
, level -> (clamp(level) * 0x7FFF * master_volume)::Int16 AS output
|
|
, x -> (x, x) AS mono
|
|
|
|
-- Basic waves
|
|
, time -> sin(time * 2 * pi()) AS sine_wave
|
|
, time -> time::UInt64 % 2 * 2 - 1 AS square_wave
|
|
, time -> (time - floor(time)) * 2 - 1 AS sawtooth_wave
|
|
, time -> abs(sawtooth_wave(time)) * 2 - 1 AS triangle_wave
|
|
|
|
-- Helpers
|
|
, (from, to, wave, time) -> from + ((wave(time) + 1) / 2) * (to - from) AS lfo
|
|
, (from, to, steps, time) -> from + floor((time - floor(time)) * steps) / steps * (to - from) AS step_lfo
|
|
, (from, to, steps, time) -> exp(step_lfo(log(from), log(to), steps, time)) AS exp_step_lfo
|
|
|
|
-- Noise
|
|
, time -> cityHash64(time) / 0xFFFFFFFFFFFFFFFF AS uniform_noise
|
|
, time -> erf(uniform_noise(time)) AS white_noise
|
|
, time -> cityHash64(time) % 2 ? 1 : -1 AS bernoulli_noise
|
|
|
|
-- Distortion
|
|
, (x, amount) -> clamp(x * amount) AS clipping
|
|
, (x, amount) -> clamp(x > 0 ? pow(x, amount) : -pow(-x, amount)) AS power_distortion
|
|
, (x, amount) -> round(x * exp2(amount)) / exp2(amount) AS bitcrush
|
|
, (time, sample_frequency) -> round(time * sample_frequency) / sample_frequency AS desample
|
|
, (time, wave, amount) -> (time - floor(time) < (1 - amount)) ? wave(time * (1 - amount)) : 0 AS thin
|
|
, (time, wave, amount) -> wave(floor(time) + pow(time - floor(time), amount)) AS skew
|
|
|
|
-- Combining
|
|
, (a, b, weight) -> a * (1 - weight) + b * weight AS combine
|
|
|
|
-- Envelopes
|
|
, (time, offset, attack, hold, release) ->
|
|
time < offset ? 0
|
|
: (time < offset + attack ? ((time - offset) / attack)
|
|
: (time < offset + attack + hold ? 1
|
|
: (time < offset + attack + hold + release ? (offset + attack + hold + release - time) / release
|
|
: 0))) AS envelope
|
|
|
|
, (bpm, time, offset, attack, hold, release) ->
|
|
envelope(
|
|
time * (bpm / 60) - floor(time * (bpm / 60)),
|
|
offset,
|
|
attack,
|
|
hold,
|
|
release) AS running_envelope
|
|
|
|
-- Sequencers
|
|
, (sequence, time) -> sequence[1 + time::UInt64 % length(sequence)] AS sequencer
|
|
|
|
-- Delay
|
|
, (time, wave, delay, decay, count) -> arraySum(n -> wave(time - delay * n) * pow(decay, n), range(count)) AS delay
|
|
|
|
|
|
, delay(time, (time -> power_distortion(sine_wave(time * 80 + sine_wave(time * 2)), lfo(0.5, 1, sine_wave, time / 16))
|
|
* running_envelope(60, time, 0, 0.0, 0.01, 0.1)),
|
|
0.2, 0.5, 5) AS kick
|
|
|
|
SELECT
|
|
|
|
(output(
|
|
kick +
|
|
delay(time, (time ->
|
|
power_distortion(
|
|
sine_wave(time * 50 + 1 * sine_wave(time * 100 + 1/4))
|
|
* running_envelope(60, time, 0, 0.01, 0.01, 0.1),
|
|
lfo(1, 0.75, triangle_wave, time / 8))),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, time / 7)
|
|
|
|
+ delay(time, (time ->
|
|
power_distortion(
|
|
sine_wave(time * sequencer([50, 100, 200, 400], time / 2) + 1 * sine_wave(time * sequencer([50, 100, 200], time / 4) + 1/4))
|
|
* running_envelope(60, time, 0.5, 0.01, 0.01, 0.1),
|
|
lfo(1, 0.75, triangle_wave, time / 8))),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, 16 + time / 11)
|
|
|
|
+ delay(time, (time ->
|
|
white_noise(time) * running_envelope(60, time, 0.75, 0.01, 0.01, 0.1)),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, 24 + time / 13)
|
|
|
|
+ sine_wave(time * 100 + 1 * sine_wave(time * 10 + 1/4))
|
|
* running_envelope(120, time, 0, 0.01, 0.01, 0.1)
|
|
),
|
|
|
|
output(
|
|
kick +
|
|
delay(time + 0.01, (time ->
|
|
power_distortion(
|
|
sine_wave(time * 50 + 1 * sine_wave(time * 100 + 1/4))
|
|
* running_envelope(60, time, 0, 0.01, 0.01, 0.1),
|
|
lfo(1, 0.75, triangle_wave, time / 8))),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, time / 7)
|
|
|
|
+ delay(time - 0.01, (time ->
|
|
power_distortion(
|
|
sine_wave(time * sequencer([50, 100, 200, 400], time / 2) + 1 * sine_wave(time * sequencer([50, 100, 200], time / 4) + 1/4))
|
|
* running_envelope(60, time, 0.5, 0.01, 0.01, 0.1),
|
|
lfo(1, 0.75, triangle_wave, time / 8))),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, 16 + time / 11)
|
|
|
|
+ delay(time + 0.005, (time ->
|
|
white_noise(time) * running_envelope(60, time, 0.75, 0.01, 0.01, 0.1)),
|
|
0.2, 0.5, 10)
|
|
* lfo(0.5, 1, triangle_wave, 24 + time / 13)
|
|
))
|
|
|
|
FROM system.numbers
|
|
LIMIT 10;
|