def smear(snd):
snd = dsp.split(snd, dsp.mstf(dsp.rand(5000, 10000)))
snd = dsp.randshuffle(snd)
snd = [dsp.env(s) for s in snd]
snd = [s * dsp.randint(1, 8) for s in snd]
return dsp.drift(''.join(snd), dsp.rand(0.01, 0.1))
def ding(tone, tlength=88200, nlength=1000):
def sequence(tonic='g'):
numdegrees = dsp.randint(2, 8)
degrees = [1, 5, 8, 11, 12]
#scale = [ dsp.randchoose(degrees) for i in range(numdegrees) ]
scale = degrees[dsp.randint(0, 3):]
scale = dsp.randshuffle(scale)
scale = tune.fromdegrees(scale, 1, tonic, tune.major, tune.terry)
return scale
numtones = tlength / nlength
numtones = 1 if numtones < 1 else numtones
freqs = [note / tune.ntf('g', 4) for note in sequence('g')]
tones = [dsp.transpose(tone, freq) for freq in freqs]
#tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength + dsp.randint(0, 500)) for i in range(numtones) ]
tones = [
dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength)
for i in range(numtones)
]
#tones = [ dsp.drift(tone, 0.03) for tone in tones ]
curve = dsp.breakpoint([0] + [dsp.rand(0, 0.01) for i in range(3)],
len(tones))
tones = [
dsp.drift(tone, curve[index % len(curve)])
for index, tone in enumerate(tones)
]
tones = [fade(tone) for tone in tones]
return dsp.amp(''.join(tones), 0.5)
def ding(tone, tlength=88200, nlength=1000):
def sequence(tonic='g'):
numdegrees = dsp.randint(2, 8)
degrees = [1,5,8,11,12]
#scale = [ dsp.randchoose(degrees) for i in range(numdegrees) ]
scale = degrees[dsp.randint(0, 3):]
scale = dsp.randshuffle(scale)
scale = tune.fromdegrees(scale, 1, tonic, tune.major, tune.terry)
return scale
numtones = tlength / nlength
numtones = 1 if numtones < 1 else numtones
freqs = [ note / tune.ntf('g', 4) for note in sequence('g') ]
tones = [ dsp.transpose(tone, freq) for freq in freqs ]
#tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength + dsp.randint(0, 500)) for i in range(numtones) ]
tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength) for i in range(numtones) ]
#tones = [ dsp.drift(tone, 0.03) for tone in tones ]
curve = dsp.breakpoint([0] + [ dsp.rand(0, 0.01) for i in range(3) ], len(tones))
tones = [ dsp.drift(tone, curve[index % len(curve)]) for index, tone in enumerate(tones) ]
tones = [ fade(tone) for tone in tones ]
return dsp.amp(''.join(tones), 0.5)
def smear(snd):
snd = dsp.split(snd, dsp.mstf(dsp.rand(5000, 10000)))
snd = dsp.randshuffle(snd)
snd = [ dsp.env(s) for s in snd ]
snd = [ s * dsp.randint(1, 8) for s in snd ]
return dsp.drift(''.join(snd), dsp.rand(0.01, 0.1))
def play(voice_id):
bpm = config('bpm')
beat = dsp.bpm2frames(bpm)
root = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
bar = beat * dsp.randchoose([8, 16, 32])
groot = tune.ntf('c')
scale = tune.fromdegrees([1,3,5,6,8,9], root=root, octave=2, ratios=ratios)
v = dsp.read('sounds/vibesc1.wav').data
out = ''
# lens = [ bar / 5, bar / 8, bar / 12 ]
lens = [ bar / 6, bar / 8, bar / 16 ]
maxbend = 2
maxbend = 0.02
layers = []
for nlen in lens:
layer = ''
nlen /= 2
note = dsp.transpose(v, (dsp.randchoose(scale) * 2**dsp.randint(0, 3)) / groot)
note = dsp.fill(note, nlen)
note = dsp.env(note, 'phasor')
note = dsp.amp(note, 0.125)
nbeats = bar / nlen
for b in range(nbeats):
b = dsp.pan(note, dsp.rand())
b = dsp.drift(b, dsp.rand(0, dsp.rand(0.01, maxbend)))
if dsp.flen(b) < nlen:
b = dsp.pad(b, 0, nlen - dsp.flen(b))
# if dsp.rand() > 0.5:
# b = dsp.vsplit(b, dsp.flen(b) / 3, dsp.flen(b) / 2)
# b = dsp.randshuffle(b)
# b = [ dsp.amp(bb, dsp.rand(0.5, 2)) for bb in b ]
# b = ''.join(b)
layer += b
# layer = dsp.fill(layer, bar)
layers += [ layer ]
out = dsp.mix(layers)
out = dsp.fill(out, bar)
return out
def makeSnare(length, i, amp):
s = ssnd
s = dsp.amp(s, 10)
s = dsp.transpose(s, dsp.rand(0.8, 1))
s = dsp.fill(s, length, silence=True)
ss = dsp.drift(s, dsp.rand(0.001, 0.1))
s = dsp.mix([s, ss])
return s
def make(length, i):
r = dsp.transpose(guitar, getRatio(scale[ i % len(scale)]))
r = dsp.mix([ dsp.pan(r, dsp.rand()), dsp.drift(dsp.pan(r, dsp.rand()), dsp.rand(0.001, 0.02)) ])
if dsp.rand() > 0.5:
r = dsp.alias(r)
if dsp.rand() > 0.5:
r = dsp.split(r, dsp.flen(r) / dsp.randint(2,5))
r = dsp.randshuffle(r)
r = ''.join(r)
r = dsp.amp(r, dsp.rand(0.1, 0.75))
g = dsp.fill(r, length, silence=True)
return g
def play(ctl):
param = ctl.get('param')
lpd = ctl.get('midi').get('lpd')
freqs = [
(10000, 15000),
(5000, 15000),
(5000, 10000),
]
low = dsp.rand(50, 100)
high = dsp.rand(80, 120)
low = 80
high = 120
wform = 'sine2pi'
amp = lpd.get(5, low=0, high=1, default=0)
low = dsp.rand(low * 0.9, low)
high = dsp.rand(high, high * 1.1)
length = dsp.mstf(lpd.get(1, low=10, high=900))
if dsp.rand() > 10.5:
length = length / 2
pulselength = lpd.geti(2, low=dsp.mstf(10), high=length, default=length)
out = dsp.bln(pulselength, low, high, wform)
out = dsp.env(out, 'phasor')
if dsp.rand() > 10.1:
beep = dsp.tone(dsp.flen(out), dsp.rand(12000, 12000), amp=dsp.rand(0.5, 1))
out = dsp.mix([out, beep])
out = dsp.drift(out, dsp.rand(0, 1))
out = dsp.pad(out, 0, length - dsp.flen(out))
out = dsp.pan(out, dsp.rand())
out = dsp.amp(out, amp)
return out
def make(length, i):
r = dsp.transpose(guitar, getRatio(scale[i % len(scale)]))
r = dsp.mix([
dsp.pan(r, dsp.rand()),
dsp.drift(dsp.pan(r, dsp.rand()), dsp.rand(0.001, 0.02))
])
if dsp.rand() > 0.5:
r = dsp.alias(r)
if dsp.rand() > 0.5:
r = dsp.split(r, dsp.flen(r) / dsp.randint(2, 5))
r = dsp.randshuffle(r)
r = ''.join(r)
r = dsp.amp(r, dsp.rand(0.1, 0.75))
g = dsp.fill(r, length, silence=True)
return g
def mixdrift(snd):
if dsp.randint(0, 4) == 0:
dsnd = dsp.drift(snd, dsp.rand(0.001, 0.04))
snd = dsp.mix([ snd, dsp.amp(dsnd, 0.5) ])
return snd
def play(params):
""" Usage:
shine.py [length] [volume]
"""
length = params.get('length', dsp.stf(dsp.rand(0.1, 1)))
volume = params.get('volume', 100.0)
volume = volume / 100.0 # TODO: move into param filter
octave = params.get('octave', 2) + 1 # Add one to compensate for an old error for now
note = params.get('note', ['c'])
note = note[0]
quality = params.get('quality', tune.major)
glitch = params.get('glitch', False)
superglitch = params.get('superglitch', False)
pinecone = params.get('pinecone', False)
glitchpad = params.get('glitch-padding', 0)
glitchenv = params.get('glitch-envelope', False)
env = params.get('envelope', False)
ratios = params.get('ratios', tune.terry)
pad = params.get('padding', False)
bend = params.get('bend', False)
bpm = params.get('bpm', 75.0)
width = params.get('width', False)
wform = params.get('waveform', False)
instrument = params.get('instrument', 'r')
scale = params.get('scale', [1,6,5,4,8])
shuffle = params.get('shuffle', False) # Reorganize input scale
reps = params.get('repeats', len(scale))
alias = params.get('alias', False)
phase = params.get('phase', False)
pi = params.get('pi', False)
wild = params.get('wii', False)
root = params.get('root', 27.5)
trigger_id = params.get('trigger_id', 0)
tune.a0 = float(root)
try:
# Available input samples
if instrument == 'r':
instrument = 'rhodes'
tone = dsp.read('sounds/synthrhodes.wav').data
elif instrument == 's':
instrument = 'synthrhodes'
tone = dsp.read('sounds/220rhodes.wav').data
elif instrument == 'c':
instrument = 'clarinet'
tone = dsp.read('sounds/clarinet.wav').data
elif instrument == 'v':
instrument = 'vibes'
tone = dsp.read('sounds/glock220.wav').data
elif instrument == 't':
instrument = 'tape triangle'
tone = dsp.read('sounds/tape220.wav').data
elif instrument == 'g':
instrument = 'glade'
tone = dsp.read('sounds/glade.wav').data
elif instrument == 'p':
instrument = 'paperclips'
tone = dsp.read('sounds/paperclips.wav').data
elif instrument == 'i':
instrument = 'input'
tone = dsp.capture(dsp.stf(1))
except:
instrument = None
tone = None
out = ''
# Shuffle the order of pitches
if shuffle is not False:
scale = dsp.randshuffle(scale)
# Translate the list of scale degrees into a list of frequencies
freqs = tune.fromdegrees(scale, octave, note, quality, ratios)
freqs = [ freq / 4.0 for freq in freqs ]
# Format is: [ [ path, offset, id, value ] ]
# Offset for video
osc_messages = [ ['/dac', float(dsp.fts(length)), 1, tune.fts(osc_freq)] for osc_freq in freqs ]
# Phase randomly chooses note lengths from a
# set of ratios derived from the current bpm
if phase is not False:
ldivs = [0.5, 0.75, 2, 3, 4]
ldiv = dsp.randchoose(ldivs)
length = dsp.bpm2ms(bpm) / ldiv
length = dsp.mstf(length)
reps = ldiv if ldiv > 1 else 4
# Construct a sequence of notes
for i in range(reps):
# Get the freqency
freq = freqs[i % len(freqs)]
# Transpose the input sample or
# synthesize tone
if wform is False and tone is not None:
# Determine the pitch shift required
# to arrive at target frequency based on
# the pitch of the original samples.
if instrument == 'clarinet':
diff = freq / 293.7
elif instrument == 'vibes':
diff = freq / 740.0
else:
diff = freq / 440.0
clang = dsp.transpose(tone, diff)
elif wform == 'super':
clang = dsp.tone(length, freq, 'phasor', 0.5)
clang = [ dsp.drift(clang, dsp.rand(0, 0.02)) for s in range(7) ]
clang = dsp.mix(clang)
elif wform is False and tone is None:
clang = dsp.tone(length, freq, 'sine2pi', 0.75)
clang = dsp.amp(clang, 0.6)
else:
clang = dsp.tone(length, freq, wform, 0.75)
clang = dsp.amp(clang, 0.6)
# Stupidly copy the note enough or
# trim it to meet the target length
clang = dsp.fill(clang, length)
# Give synth tones simple env (can override)
if wform is not False and env is False:
clang = dsp.env(clang, 'phasor')
# Apply an optional amplitude envelope
if env is not False:
clang = dsp.env(clang, env)
# Add optional padding between notes
if pad != False:
clang = dsp.pad(clang, 0, pad)
# Add to the final note sequence
out += clang
# Add optional aliasing (crude bitcrushing)
if alias is not False:
out = dsp.alias(out)
# Cut sound into chunks of variable length (between 5 & 300 ms)
# Pan each chunk to a random position
# Apply a sine amplitude envelope to each chunk
# Finally, add variable silence between each chunk and shuffle the
# order of the chunks before joining.
if glitch is not False:
out = dsp.vsplit(out, dsp.mstf(5), dsp.mstf(300))
out = [dsp.pan(o, dsp.rand()) for o in out]
out = [dsp.env(o, 'sine') for o in out]
out = [dsp.pad(o, 0, dsp.mstf(dsp.rand(0, glitchpad))) for o in out]
out = ''.join(dsp.randshuffle(out))
# Detune between 1.01 and 0.99 times original speed
# as a sine curve whose length equals the total output length
if bend is not False:
out = dsp.split(out, 441)
freqs = dsp.wavetable('sine', len(out), 1.01, 0.99)
out = [ dsp.transpose(out[i], freqs[i]) for i in range(len(out)) ]
out = ''.join(out)
if wild is not False:
#out = dsp.vsplit(out, 400, 10000)
out = dsp.split(out, 3000)
out = [ dsp.amp(dsp.amp(o, dsp.rand(10, 50)), 0.5) for o in out ]
#out = [ o * dsp.randint(1, 5) for o in out ]
for index, o in enumerate(out):
if dsp.randint(0, 1) == 0:
out[index] = dsp.env(dsp.cut(o, 0, dsp.flen(o) / 4), 'gauss') * 4
if dsp.randint(0, 6) == 0:
out[index] = dsp.transpose(o, 8)
out = [ dsp.env(o, 'gauss') for o in out ]
freqs = dsp.wavetable('sine', len(out), 1.02, 0.98)
out = [ dsp.transpose(out[i], freqs[i]) for i in range(len(out)) ]
out = ''.join(out)
if pinecone == True:
out = dsp.pine(out, int(length * dsp.rand(0.5, 8.0)), dsp.randchoose(freqs) * dsp.rand(0.5, 4.0))
# Adjust output amplitude as needed and return audio + OSC
if pi:
return (dsp.amp(out, volume), {'osc': osc_messages})
else:
return dsp.amp(out, volume)
def play(voice_id):
tel = bot.getTel()
bpm = s.config('bpm')
#if 'gentle' in tel['name'] or 'upbeat' in tel['name'] or 'full' in tel['name']:
#dsp.log('')
#dsp.log(voice_id + ' chirps silent')
#return dsp.pad('', 0, dsp.stf(dsp.rand(1, 10)))
length = int((1.0 / (tel['pace'] / 10.0)) * dsp.stf(3))
def makecurve(length):
# freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, amp
wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for i in range(int(dsp.rand(5, 30))) ] + [0], 1024)
win = dsp.breakpoint([0] + [ dsp.rand(0, 1) for i in range(4) ] + [0], 1024)
mod = dsp.breakpoint([ dsp.rand(0, 1) for i in range(int(dsp.rand(4, 8))) ], 1024)
smaxamp = dsp.rand(0.65, 0.95)
amp = dsp.rand(0.01, smaxamp)
pw = dsp.rand(0.1, 1.0)
if 'upbeat' in tel['name']:
wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for i in range(int(dsp.rand(5, 30))) ] + [0], 1024)
win = dsp.breakpoint([0] + [ dsp.rand(0, 1) for i in range(4) ] + [0], 1024)
mod = dsp.breakpoint([ dsp.rand(0, 1) for i in range(int(dsp.rand(5, 80))) ], 1024)
pw = 1.0
if 'ballsout' in tel['name']:
wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for i in range(int(dsp.rand(10, 40))) ] + [0], 1024)
win = dsp.breakpoint([0] + [ dsp.rand(0, 1) for i in range(10) ] + [0], 1024)
mod = dsp.breakpoint([ dsp.rand(0, 1) for i in range(int(dsp.rand(20, 100))) ], 1024)
if 'sparse' in tel['name']:
amp = dsp.rand(0.7, 3)
freq = tel['register'] * tel['roughness'] * (tel['density'] * tel['pace'] * 0.25)
#if dsp.rand(0, 100) > 50:
#freq = dsp.rand(2, 20)
modR = tel['harmonicity']
modF= tel['pace'] / 10.0
c = dsp.pulsar(freq, length, pw, wf, win, mod, modR, modF, amp)
ngrains = len(c)
pans = dsp.breakpoint([ dsp.rand(0,1) for i in range(100) ], ngrains)
maxPad = dsp.randint(2000, 4000)
if 'sparse' in tel['name']:
c = dsp.vsplit(c, dsp.mstf(0.5), dsp.mstf(tel['density'] * tel['harmonicity'] * tel['roughness'] * tel['pace']))
c = [ dsp.randchoose(c) for i in range(int(dsp.rand(3, 10))) ]
elif 'ballsout' in tel['name']:
c = dsp.vsplit(c, dsp.mstf(0.1), dsp.mstf(400))
c = dsp.packet_shuffle(c, dsp.randint(5, 10))
speeds = dsp.breakpoint([ dsp.rand(tel['register'] * 0.1 + 0.2, tel['register'] + 0.2) for i in range(100) ], ngrains)
#c = [ dsp.transpose(cg, speeds[i]) for i, cg in enumerate(c) ]
#c = [ dsp.amp(cg, dsp.rand(0.25, 1.25)) for i, cg in enumerate(c) ]
for ic, cc in enumerate(c):
if dsp.rand(0, 100) > 70:
c[ic] = dsp.tone(dsp.flen(cc), 11000, amp=0.5)
elif 'upbeat' in tel['name']:
beat = dsp.bpm2frames(bpm)
c = dsp.split(c, beat)
maxPad = 0
c = [ dsp.pad(cg, 0, dsp.mstf(dsp.rand(10, beat / 4))) for i, cg in enumerate(c) ]
else:
c = dsp.vsplit(c, dsp.mstf(10), dsp.mstf(tel['density'] * tel['harmonicity'] * tel['roughness'] * tel['pace'] * dsp.rand(1, 10)))
c = [ dsp.pan(cg, pans[i]) for i, cg in enumerate(c) ]
c = [ dsp.env(cg, 'sine') for i, cg in enumerate(c) ]
if 'sparse' in tel['name'] or 'ballsout' in tel['name']:
speeds = dsp.breakpoint([ dsp.rand(0.5, 1.99) for i in range(100) ], ngrains)
for ic, cc in enumerate(c):
if dsp.flen(cc) < dsp.mstf(100):
c[ic] = cc + ''.join([ dsp.amp(cc, dsp.rand(0.1, 1.0)) for buh in range(dsp.randint(1, int(tel['density']))) ])
#c = [ dsp.transpose(cg, speeds[i]) for i, cg in enumerate(c) ]
c = [ dsp.pan(cg, dsp.rand(0.0, 1.0)) for i, cg in enumerate(c) ]
if 'ballsout' not in tel['name']:
c = [ dsp.pad(cg, 0, dsp.mstf(dsp.rand(10, maxPad))) for i, cg in enumerate(c) ]
out = ''.join(c)
return out
out = makecurve(length)
if dsp.flen(out) > dsp.mstf(100) and dsp.rand(0, 100) > 30:
out = dsp.drift(out, (tel['harmonicity'] - 10.0) * -1 * 0.5, dsp.randint(41, 441))
if dsp.flen(out) > dsp.stf(10):
out = dsp.fill(out, dsp.stf(10))
if dsp.rand(0, 100) > 50:
out = dsp.vsplit(out, 41, 441)
for ii, o in enumerate(out):
if dsp.rand(0, 100) > 50:
out[ii] = dsp.pad('', 0, dsp.flen(o))
elif dsp.rand(0, 100) > 50:
out[ii] = dsp.amp(o, dsp.rand(0.75, 3))
out = [ dsp.pan(o, dsp.rand()) for o in out ]
out = ''.join(out)
dsp.log('')
dsp.log('chirp')
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def play(ctl):
param = ctl.get('param')
lpd = ctl.get('midi').get('lpd')
scale = [ dsp.randchoose([1, 3, 5, 6, 8]) for s in range(dsp.randint(2, 4)) ]
#scale = [ dsp.randchoose([1, 2, 4, 6, 8]) for s in range(dsp.randint(2, 4)) ]
freqs = tune.fromdegrees(scale, root='a', octave=dsp.randint(2,3), scale=tune.minor)
freq = dsp.randchoose(freqs)
pw = lpd.get(2, low=0.01, high=1, default=1)
pw = dsp.rand(0.01, 1)
modr = lpd.get(6, low=0.001, high=0.1)
modr = dsp.rand(0.001, 0.05)
#modr = dsp.rand(0.1, 10.5)
#modr = dsp.rand(0.001, 0.01)
modr = dsp.rand(0, modr)
modf = dsp.rand(0.01, 0.05)
amp = lpd.get(1, low=0, high=2, default=0)
#amp = dsp.rand(0.1, 0.5)
#amp = 0
length = dsp.stf(lpd.get(5, low=0.5, high=14, default=1) * dsp.rand(0.75, 2))
length = dsp.stf(dsp.rand(5.5, 24) * dsp.rand(0.75, 2))
#length = dsp.stf(dsp.rand(0.5, 0.75) * dsp.rand(0.75, 2))
wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for w in range(10) ] + [0], 512)
#wf = dsp.wavetable('sine2pi', 512)
#wf = dsp.wavetable('sine2pi', 512)
#win = dsp.wavetable('sine', 512)
win = dsp.breakpoint([0] + [ dsp.rand(0, 1) for w in range(5) ] + [0], 512)
mod = dsp.breakpoint([0] + [ dsp.rand(0, 1) for m in range(5) ] + [0], 512)
layers = []
harmonics = [1, 2, 3, 4]
for harmonic in harmonics:
f = freq * harmonic
if harmonic > 4:
a = dsp.rand(0.05, 0.1)
else:
a = amp * dsp.rand(0.1, 0.5)
layer = dsp.pulsar(f, length, pw, wf, win, mod, modr, modf, a * 2)
layer = dsp.env(layer, dsp.randchoose(['sine', 'tri', 'line', 'phasor']))
layer = dsp.taper(layer)
layer = dsp.pan(layer, dsp.rand())
layer = dsp.mix([ dsp.drift(layer, dsp.rand(0.01, 0.03)), layer ])
if dsp.rand() > 0.5:
layer = dsp.vsplit(layer, dsp.mstf(50), dsp.mstf(500))
bit = dsp.randchoose(layer)
bit = bit * dsp.randint(1, 3)
bit = dsp.transpose(bit, dsp.randchoose([1, 2, 4, 8]))
layer = ''.join(layer)
layer = dsp.insert_into(layer, bit, dsp.randint(0, dsp.flen(layer) - dsp.flen(bit)))
layers += [ layer ]
out = dsp.mix(layers)
out = dsp.env(out, 'sine')
out = dsp.env(out, 'hann')
#out = dsp.env(out, 'phasor')
out = dsp.taper(out)
return out
def mixdrift(snd):
if dsp.randint(0, 4) == 0:
dsnd = dsp.drift(snd, dsp.rand(0.001, 0.04))
snd = dsp.mix([snd, dsp.amp(dsnd, 0.5)])
return snd
def play(ctl):
param = ctl.get('param')
lpd = ctl.get('midi').get('lpd')
pc = ctl.get('midi').get('pc')
#pc.setOffset(111)
gamut = {
'high': [
(10000, 15000),
(5000, 15000),
(5000, 10000),
],
'mid': [
(1000, 5000),
(1000, 2000),
],
'pitch': [
tuple([ dsp.rand(500, 2000) for p in range(2) ]),
tuple([ dsp.rand(100, 1000) for p in range(2) ]),
tuple([ dsp.rand(1000, 5000) for p in range(2) ]),
],
'low': [
(20, 5000),
(30, 10000),
(40, 10000),
]
}
area = param.get('wash-area', default='high')
area = dsp.randchoose(['high', 'mid', 'pitch', 'low'])
area = 'pitch'
dsp.log(area)
freqs = dsp.randchoose(gamut[area])
freqscale = pc.get(16, low=0.125, high=2, default=1)
#freqscale = dsp.rand(0.125, 2)
low = freqs[0] * freqscale
high = freqs[1] * freqscale
wform = dsp.randchoose(['sine2pi', 'tri', 'vary', 'square'])
timescale = pc.get(17, low=1, high=4, default=1)
#timescale = dsp.rand(1, 4)
lengthscale = pc.get(18, low=0.125, high=2.5)
#lengthscale = dsp.rand(0.125, 2.5)
amp = pc.get(0, low=0, high=0.5, default=0.5)
#amp = dsp.rand(0, 0.5)
if area == 'high':
low = dsp.rand(low * 0.9, low)
high = dsp.rand(high, high * 1.1)
length = dsp.stf(dsp.rand(0.01, 0.3) * lengthscale)
out = dsp.bln(length, low, high, wform)
out = dsp.env(out, 'phasor')
if dsp.rand() > 10.5:
beep = dsp.tone(dsp.flen(out), high * 2, amp=dsp.rand(0.5, 1))
out = dsp.mix([out, beep])
out = dsp.pad(out, 0, dsp.mstf(dsp.rand(1, 400) * timescale))
out = out * dsp.randint(1, 3)
out = dsp.drift(out, dsp.rand(0, 1))
elif area == 'mid':
low = dsp.rand(low * 0.9, low)
high = dsp.rand(high, high * 1.1)
length = dsp.stf(dsp.rand(0.01, 0.5) * lengthscale)
out = dsp.bln(length, low, high, wform)
out = dsp.env(out, 'random')
if timescale > 1:
out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5)))
elif area == 'pitch':
low = dsp.rand(low * 0.9, low)
high = dsp.rand(high, high * 1.1)
length = dsp.stf(dsp.rand(0.01, 0.5) * lengthscale)
out = dsp.bln(length, low, high, wform)
out = dsp.env(out, 'random')
if timescale > 1:
out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5)))
elif area == 'low':
low = dsp.rand(low * 0.9, low)
high = dsp.rand(high, high * 1.1)
length = dsp.stf(dsp.rand(0.2, 2) * lengthscale)
out = dsp.bln(length, low, high, wform)
out = dsp.env(out, 'random')
out = dsp.mix([out, dsp.tone(length, low)])
if dsp.rand() > 0.5:
beep = dsp.tone(dsp.flen(out), high, amp=dsp.rand(0.015, 0.1), wavetype=dsp.randchoose(['hann', 'impulse', 'square', 'vary', 'sine']))
out = dsp.mix([out, beep])
if timescale > 1:
out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5)))
if dsp.rand() > pc.get(19, low=0, high=1, default=0.75):
plength = length * dsp.randint(2, 6)
freq = tune.ntf(param.get('key', default='c'), octave=dsp.randint(0, 4))
out = dsp.mix([ dsp.pine(out, plength, freq), dsp.pine(out, plength, freq * 1.25) ])
out = dsp.fill(out, length)
out = dsp.pan(out, dsp.rand())
out = dsp.amp(out, amp)
return out
def play(params):
length = params.get('length', dsp.stf(2))
volume = params.get('volume', 100.0)
volume = volume / 100.0 # TODO: move into param filter
width = params.get('width', 50)
measures = params.get('multiple', 1)
beats = params.get('repeats', 8)
bpm = params.get('bpm', 75.0)
glitch = params.get('glitch', False)
alias = params.get('alias', False)
skitter = params.get('skitter', False)
bend = params.get('bend', False)
tweet = params.get('tweet', False)
pattern = params.get('pattern', True)
playdrums = params.get('drum', ['k', 'h', 'c'])
pinecone = params.get('pinecone', False)
insamp = params.get('rec', False)
roll = params.get('roll', False)
pi = params.get('pi', False)
def bln(length, low=3000.0, high=7100.0, wform='sine2pi'):
""" Time-domain band-limited noise generator
"""
outlen = 0
cycles = ''
while outlen < length:
cycle = dsp.cycle(dsp.rand(low, high), wform)
outlen += len(cycle)
cycles += cycle
return cycles
def eu(length, numpulses):
pulses = [ 1 for pulse in range(numpulses) ]
pauses = [ 0 for pause in range(length - numpulses) ]
position = 0
while len(pauses) > 0:
try:
index = pulses.index(1, position)
pulses.insert(index + 1, pauses.pop(0))
position = index + 1
except ValueError:
position = 0
return pulses
def getevents(lenbeat, pattern):
""" Takes pattern: [0, 1]
Returns event list: [[0, 44100], [1, 44100]]
"""
events = []
count = 0
value = None
event = []
for p in pattern:
prev = value
value = p
# Null to zero always starts new zero
if prev is None and value is 0:
# Start zero, add to length
event = [0, lenbeat]
# Any transition to one always starts new one
elif value is 1:
# Add last event if not empty to events and start a new one
if len(event) == 2:
events += [ event ]
# Start one, add to length
event = [1, lenbeat]
# One to zero always adds to one
# Zero to zero always adds to zero
elif prev is 0 or prev is 1 and value is 0:
# Add to length
event[1] += lenbeat
return events
def clap(amp, length):
# Two layers of noise: lowmid and high
out = dsp.mix([ bln(int(length * 0.2), 600, 1200), bln(int(length * 0.2), 7000, 9000) ])
out = dsp.env(out, 'phasor')
out = dsp.pad(out, 0, length - dsp.flen(out))
return out
def hihat(amp, length):
def hat(length):
if dsp.randint(0, 6) == 0:
out = bln(length, 9000, 14000)
out = dsp.env(out, 'line')
else:
out = bln(int(length * 0.05), 9000, 14000)
out = dsp.env(out, 'phasor')
out = dsp.pad(out, 0, length - dsp.flen(out))
return out
if dsp.randint() == 0:
out = ''.join([ hat(length / 2), hat(length / 2) ])
else:
out = hat(length)
return out
def snare(amp, length):
# Two layers of noise: lowmid and high
out = dsp.mix([ bln(int(length * 0.2), 700, 3200, 'impulse'), bln(int(length * 0.01), 7000, 9000) ])
out = dsp.env(out, 'phasor')
out = dsp.pad(out, 0, length - dsp.flen(out))
return out
def kick(amp, length):
fhigh = 160.0
flow = 60.0
fdelta = fhigh - flow
target = length
pos = 0
fpos = fhigh
out = ''
while pos < target:
# Add single cycle
# Decrease pitch by amount relative to cycle len
cycle = dsp.cycle(fpos)
#cycle = ''.join([ str(v) for v in dsp.curve(0, dsp.htf(fpos), math.pi * 2) ])
pos += dsp.flen(cycle)
#fpos = fpos - (fhigh * (length / dsp.htf(fpos)))
fpos = fpos - 30.0
out += cycle
return dsp.env(out, 'phasor')
beats = beats * measures
drums = [{
'name': 'clap',
'shortname': 'c',
'trigger_id': 5,
'gen': clap,
'pat': eu(beats, dsp.randint(1, beats / 3)),
}, {
'name': 'hihat',
'shortname': 'h',
'trigger_id': 3,
'gen': hihat,
'pat': eu(beats, dsp.randint(1, beats / 3)),
}, {
'name': 'snare',
'shortname': 's',
'trigger_id': 4,
'gen': snare,
'pat': eu(beats, dsp.randint(1, beats / 2)),
}, {
'name': 'kick',
'shortname': 'k',
'trigger_id': 2,
'gen': kick,
'pat': eu(beats, dsp.randint(1, beats / 3)),
}]
out = ''
lenbeat = dsp.mstf(60000.0 / bpm) / 4
layers = []
streams = []
for drum in drums:
if drum['shortname'] in playdrums:
events = getevents(lenbeat, drum['pat'])
layers += [ ''.join([ drum['gen'](event[0], event[1]) for event in events ]) ]
if drum['shortname'] == 's':
osc_messages = [ ['/tick', dsp.fts(lenbeat), drum['trigger_id'], int(h)] for h in drum['pat'] ]
#stream = []
#for h in drum['pat']:
#stream += [ ('/tick/' + str(drum['trigger_id']), int(h), dsp.fts(lenbeat)) ]
#streams += [ stream ]
out = dsp.mix(layers)
if bend is True:
out = dsp.drift(out, dsp.rand(0.1, 2))
if alias is True:
out = dsp.alias(out)
if glitch == True:
out = dsp.split(out, int(lenbeat * 0.5))
out = ''.join(dsp.randshuffle(out))
return dsp.amp(out, volume)
from pippi import dsp
from pippi import tune
from hcj import keys
chords = tune.chords(['i', 'vi9', 'iii7', 'v'],
'a',
octave=3,
ratios=tune.terry)
out = ''
for chord in chords * 4:
layers = []
length = dsp.stf(dsp.rand(3, 4))
for freq in chord:
layer = keys.rhodes(length, freq, dsp.rand(0.1, 0.2))
layer = dsp.pan(layer, dsp.rand())
layer = dsp.drift(layer, dsp.rand(0, 0.01))
layers += [layer]
chord = dsp.mix(layers)
chord = dsp.drift(chord, dsp.rand(0, 0.01))
out += chord
dsp.write(out, 'chordsweep')
