def play(ctl):
freq = tune.ntf(dsp.randchoose(['eb']), octave=dsp.randint(0,2))
synth = keys.rhodes(dsp.stf(4), freq)
s = dsp.vsplit(synth, dsp.mstf(50), dsp.mstf(2000))
s = dsp.randshuffle(s)
#s = [ dsp.alias(ss) for ss in s ]
s = [ dsp.amp(ss, dsp.rand(0.5, 0.75)) for ss in s ]
s = [ dsp.pan(ss, dsp.rand(0, 1)) for ss in s ]
s = ''.join(s)
s = dsp.fill(s, dsp.flen(synth))
s2 = dsp.vsplit(synth, dsp.mstf(150), dsp.mstf(1500))
s2 = dsp.randshuffle(s2)
s2 = [ dsp.transpose(ss, dsp.randchoose([1,1.5,2,3,4,8])) for ss in s2 ]
s2 = [ dsp.env(ss, 'phasor') for ss in s2 ]
s2 = ''.join(s2)
out = dsp.mix([ s, s2 ])
out = dsp.amp(out, 1.5)
out = dsp.transpose(out, 1.01)
#synth = dsp.fill(synth, dsp.flen(main))
#out = synth
return out
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 makeGrains():
guitar = dsp.randchoose(guitars)
guitar = dsp.transpose(guitar, dsp.randchoose([1, 2, 3, 4, 8]))
max_grain_length = dsp.mstf(dsp.rand(10, 500))
positions = [
math.floor(pos * (dsp.flen(guitar) - max_grain_length))
for pos in makeShape()
]
lengths = [
math.floor(length * (max_grain_length - 1) + 1)
for length in makeShape()
]
pans = makeShape()
amps = [amp * dsp.rand(0, 10) for amp in makeShape()]
num_grains = dsp.randint(500, 1000)
grains = []
for i in range(num_grains):
grain = dsp.cut(guitar, positions[i % len(positions)],
lengths[i % len(lengths)])
grain = dsp.pan(grain, pans[i % len(pans)])
grain = dsp.amp(grain, amps[i % len(amps)])
grain = dsp.taper(grain, 20)
grains += [grain]
return ''.join(grains)
def clap2(beat):
nlens = [
beat * 2,
beat,
beat / 2,
]
# length of pattern (in beats)
nbeats = dsp.randint(10, 15)
# beat lengths (from a set of bpm-derived note lengths defined in the nlens list)
blens = [dsp.randchoose(nlens) for b in range(nbeats)]
out = ''
# synthesize the tones
for i in range(nbeats):
beat = dsp.transpose(dsp.randchoose([c1, c2]),
dsp.rand(0.25, 40.0))
beat = dsp.pad(beat, 0, blens[i] - dsp.flen(beat))
beat = dsp.amp(beat, dsp.rand(1, 4))
# add it to the output
out += beat
return out
def play(ctl):
dpc = ctl.get('midi').get('dpc')
lpd = ctl.get('midi').get('lpd')
print lpd.get(1)
dpc.setOffset(111)
pw = dpc.get(1, low=0.01, high=1)
scale = [1, 2, 3, 6, 9]
scale = [1, 4, 6, 8]
scale = [1, 3, 5, 9]
scale = tune.fromdegrees(scale, octave = dpc.geti(4, low=0, high=4))
freq = dsp.randchoose(scale)
length = dsp.stf(dpc.get(2, low=0.1, high=8) * dsp.rand(0.5, 1.5))
wf = dsp.wavetable('sine2pi')
win = dsp.wavetable('sine')
mod = [ dsp.rand(0, 1) for m in range(1000) ]
modr = dpc.get(5, low=0, high=0.3)
modf = dpc.get(6, low=0.001, high=10)
amp = dpc.get(3, low=0, high=1)
out = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp)
out = dsp.env(out, dsp.randchoose(['sine', 'tri']))
out = dsp.pan(out, dsp.rand())
return out
def fracture(snd):
numpoints = dsp.randint(3, 20)
poscurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints)
poscurve = [ p * (dsp.flen(snd) - dsp.mstf(210)) for p in poscurve ]
lencurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints)
lencurve = [ l * dsp.mstf(200) + dsp.mstf(10) for l in lencurve ]
pancurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints)
prepadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints)
prepadcurve = [ int(p * dsp.mstf(20)) for p in prepadcurve ]
postpadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints)
postpadcurve = [ int(p * dsp.mstf(20)) for p in postpadcurve ]
speeds = [1.0, 2.0, 0.5, 0.75]
grains = [ dsp.cut(snd, poscurve[i], lencurve[i]) for i in range(numpoints) ]
grains = [ dsp.pan(grains[i], pancurve[i]) for i in range(numpoints) ]
grains = [ dsp.env(grain, 'gauss', True) for grain in grains ]
grains = [ dsp.transpose(grain, dsp.randchoose(speeds)) for grain in grains ]
grains = [ dsp.pad(grains[i], prepadcurve[i], postpadcurve[i]) for i in range(numpoints) ]
for i in range(numpoints):
if dsp.randint(0, 3) == 0:
grains[i] = slurp(grains[i])
etypes = ['line', 'phasor', 'tri', 'sine', 'gauss']
snd = dsp.env(''.join(grains), dsp.randchoose(etypes))
snd = dsp.pad(snd, 0, dsp.mstf(dsp.rand(100, 400)))
return snd
def clap2(beat):
nlens = [
beat * 2,
beat,
beat / 2,
]
# length of pattern (in beats)
nbeats = dsp.randint(10, 15)
# beat lengths (from a set of bpm-derived note lengths defined in the nlens list)
blens = [ dsp.randchoose(nlens) for b in range(nbeats) ]
out = ''
# synthesize the tones
for i in range(nbeats):
beat = dsp.transpose(dsp.randchoose([c1,c2]), dsp.rand(0.25, 40.0))
beat = dsp.pad(beat, 0, blens[i] - dsp.flen(beat))
beat = dsp.amp(beat, dsp.rand(1, 4))
# add it to the output
out += beat
return out
def play(voice_id):
tel = bot.getTel()
degrees = [ dsp.randchoose([1, 2, 3, 5, 6, 8]) for f in range(dsp.randint(2, 20)) ]
#degrees = [ dsp.randchoose([1, 5, 6, 7, 8]) for f in range(dsp.randint(2, 10)) ]
octave = dsp.randint(1, 4)
freqs = tune.fromdegrees(degrees, root='c', octave=octave, ratios=tune.terry)
out = ''
for r in range(dsp.randint(2, 20)):
freq = dsp.randchoose(freqs)
waveform = dsp.randchoose(['tri', 'sine2pi'])
length = dsp.randint(dsp.mstf(1), dsp.mstf(4000))
#length = dsp.mstf(1500)
#length = dsp.mstf(2500)
pulsewidth = dsp.rand(0.01, 1)
mod = dsp.breakpoint([ dsp.rand() for b in range(int(round(tel['density'])) + 3) ], 512)
window = dsp.breakpoint([0] + [ dsp.rand() for b in range(int(round(tel['harmonicity'] * 2)) + 3) ] + [0], 512)
waveform = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for b in range(int(round(tel['roughness'] * dsp.randint(1, 4))) + 3) ] + [0], 512)
modRange = dsp.rand(0.01, 100.08)
modFreq = dsp.rand(0.0001, 5)
volume = dsp.rand(0.2, 0.3) * (tel['density'] / 10.0)
#volume = dsp.rand(0.2, 0.8)
t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
#t = dsp.tone(length, freq, waveform)
t = dsp.pan(t, dsp.rand())
t = dsp.alias(t)
t = dsp.amp(t, dsp.rand(0.5, 15.0))
t = dsp.pad(t, 0, dsp.randint(dsp.mstf(1), dsp.mstf(10)))
t = dsp.amp(t, dsp.rand(0.5, 0.95))
t = dsp.env(t, 'sine')
#t = dsp.env(t, 'phasor')
#t = dsp.pine(t, dsp.flen(t) * 4, freq)
out += t
dsp.log('')
dsp.log('boone')
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def play(ctl):
#out = snds.load('genie/piano.wav')
lenrange = 300
minlen = 1
if dsp.rand() > 0.5:
lengths = dsp.breakpoint([dsp.rand(0, 1) for _ in range(5)], 50)
else:
lengths = dsp.wavetable('sine', 50)
lengths = [dsp.mstf(l * lenrange + minlen) for l in lengths]
out = ''
for length in lengths:
freq = tune.ntf('f', octave=dsp.randint(2, 5))
if dsp.rand() > 10.85:
length = dsp.stf(dsp.rand(0.5, 3))
freq = dsp.randchoose(
tune.fromdegrees([1, 3, 4, 5, 6], octave=4, root='f'))
out += keys.pulsar(freq=freq, length=length, env='phasor')
if dsp.rand() > 10.75:
freq = dsp.randchoose(
tune.fromdegrees([1, 3, 4, 5, 6], octave=4, root='f'))
return out
def play(voice_id):
bpm = config('bpm')
key = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
beat = dsp.bpm2frames(bpm)
nlen = beat / dsp.randchoose([4,5,6,7,8,9,10])
root = 340.0
target = tune.ntf(key)
n = dsp.read('sounds/mike.wav').data
n = dsp.transpose(n, target / root)
n = dsp.amp(n, 0.4)
length = dsp.randint(16, 64) * beat
ngrains = length / nlen
n = dsp.transpose(n, dsp.randchoose([0.5, 1, 2, 2, 4, 4]))
n = dsp.split(n, nlen)
snd = dsp.randchoose(n)
snd = dsp.env(snd, 'sine')
grains = [ snd for i in range(ngrains) ]
grains = [ dsp.pan(grain, dsp.rand()) for grain in grains ]
out = ''.join(grains)
out = dsp.env(out, 'sine')
# out = dsp.pad(out, 0, dsp.stf(dsp.randint(0.5, 3)))
return out
def play(ctl):
param = ctl.get("param")
pc = ctl.get("midi").get("pc")
pc.setOffset(111)
lpd = ctl.get("midi").get("lpd")
amp = pc.get(7)
snds = ["sounds/melodica.wav", "sounds/rhodes.wav", "sounds/chime.wav", "sounds/bell.wav", "sounds/lap.wav"]
# snds = ['sounds/rhodes.wav']
m = dsp.read(dsp.randchoose(snds)).data
m = dsp.transpose(m, 0.125)
m = dsp.transpose(m, dsp.randchoose([1, 1.5, 2, 3]) * 2 ** dsp.randint(0, 3))
m = dsp.fill(m, dsp.stf(pc.get(15, low=0.125, high=2)))
reverse = dsp.randchoose([True, False])
numlayers = dsp.randint(10, 20)
numgrains = dsp.randint(pc.geti(8, low=3, high=10), pc.geti(8, low=10, high=20))
minlen = dsp.rand(10, 100)
# lenranges = (dsp.rand(10, 20), dsp.rand(50, 1000))
lenranges = (pc.get(15, low=10, high=50), pc.get(15, low=50, high=500))
env = dsp.randchoose(["sine", "hann", "tri", "vary"])
# out = m
out = fx.spider(m, numlayers, numgrains, minlen, lenranges, reverse)
out = dsp.amp(out, amp)
# out = dsp.env(out, 'sine')
# out = dsp.alias(out)
return out
def play(voice_id):
volume = P(voice_id, 'volume', 100.0)
volume = volume / 100.0 # TODO: move into param filter
volume = volume * 0.65
length = P(voice_id, 'length', 40)
env = False
wii = False
# wii = True
speed = False
numcycles = dsp.randint(1, 200)
# Make breakpoint env with 2-10 vals between 0.1 and 1.0
curve_a = dsp.breakpoint([1.0] + [dsp.rand(0.1, 1.0) for r in range(dsp.randint(2, 10))] + [0], numcycles)
# Make wavetable with single cycle from given wave types
curve_types = ['vary', 'phasor', 'sine', 'cos', 'impulse']
curve_b = dsp.wavetable(dsp.randchoose(curve_types), numcycles)
# Make pan curve - always cosine
pan = dsp.breakpoint([ dsp.rand() for i in range(dsp.randint(5, 50)) ], numcycles)
amps = dsp.breakpoint([ dsp.rand(0.1, 0.75) for i in range(dsp.randint(5, 30)) ], numcycles)
# Multiply breakpoint curve with simple wavetable
wtable = [ curve_a[i] * curve_b[i] for i in range(numcycles) ]
# Scale to max frequency
wtable = [ (f * 20000) + length for f in wtable ]
# Possible osc wavetypes
wtypes = ['sine2pi']
# wtypes = ['tri', 'sine2pi', 'impulse']
# wtypes = ['impulse', 'tri', 'cos', 'sine2pi', 'vary']
if wii is True:
out = [ dsp.pan(dsp.cycle(wtable[i], dsp.randchoose(wtypes)), pan[i]) for i in range(numcycles) ]
else:
wtype = dsp.randchoose(wtypes)
out = [ dsp.pan(dsp.cycle(wtable[i], wtype), pan[i]) for i in range(numcycles) ]
out = [ dsp.amp(oo, amps[i]) for i, oo in enumerate(out) ]
out = dsp.amp(''.join(out), volume)
if speed != False and speed > 0.0:
out = dsp.transpose(out, speed)
if env != False:
out = dsp.env(out, env)
return out
def makeLong(seg):
g = dsp.randchoose(guitars)
g = dsp.amp(g, 0.4)
long_guitar = dsp.fill(g, sum(seg))
fade_guitar = dsp.randchoose(guitars)
fade_guitar = dsp.amp(fade_guitar, dsp.rand(0.1, 0.3))
fade_guitar = fx.penv(fade_guitar)
fade_guitar = dsp.fill(fade_guitar, sum(seg))
out = dsp.mix([long_guitar, fade_guitar])
return out
def makeLong(seg):
g = dsp.randchoose(guitars)
g = dsp.amp(g, 0.4)
long_guitar = dsp.fill(g, sum(seg))
fade_guitar = dsp.randchoose(guitars)
fade_guitar = dsp.amp(fade_guitar, dsp.rand(0.1, 0.3))
fade_guitar = fx.penv(fade_guitar)
fade_guitar = dsp.fill(fade_guitar, sum(seg))
out = dsp.mix([ long_guitar, fade_guitar ])
return out
def play(voice_id):
tel = bot.getTel()
freqs = tune.fromdegrees([ dsp.randchoose([1, 2, 3, 5, 6, 8]) for f in range(dsp.randint(2, 5)) ], root='c', octave=dsp.randint(1, 3), ratios=tune.just)
out = ''
for freq in freqs:
waveform = dsp.randchoose(['tri', 'sine2pi'])
length = dsp.randint(dsp.mstf(10), dsp.mstf(300))
#length = dsp.mstf(150)
pulsewidth = dsp.rand()
mod = dsp.breakpoint([ dsp.rand() for b in range(int(round(tel['density'])) + 3) ], 512)
window = dsp.breakpoint([0] + [ dsp.rand() for b in range(int(round(tel['harmonicity'] * 2)) + 3) ] + [0], 512)
waveform = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for b in range(int(round(tel['roughness'] * 3)) + 3) ] + [0], 512)
modRange = 0.005
modFreq = dsp.rand(0.0001, 5)
volume = dsp.rand(0.2, 0.3)
if dsp.rand(0, 100) > 50:
t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
else:
t = dsp.tone(length, freq, waveform)
#t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
#t = dsp.tone(length, freq, waveform)
t = dsp.pan(t, dsp.rand())
t = dsp.alias(t)
t = dsp.amp(t, dsp.rand(0.5, 5.0))
t = dsp.pad(t, 0, dsp.randint(dsp.mstf(1), dsp.mstf(500)))
#t = dsp.pad(t, 0, dsp.mstf(100))
t = dsp.amp(t, dsp.rand(0.5, 0.75))
#out += dsp.env(t, 'sine')
out += t
#out = dsp.env(t, 'sine')
dsp.log('')
dsp.log('boone')
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def that(li):
print 'layer', li
freqs = tune.fromdegrees([ dsp.randint(1, 20) for f in range(dsp.randint(3, 6)) ], octave = 3)
length = dsp.stf(dsp.rand(10, 20))
layers = []
for fi, freq in enumerate(freqs):
print ' tone', fi, round(dsp.fts(length), 2)
waveform = dsp.randchoose(['sine2pi', 'tri', 'hann'])
waveform = dsp.wavetable(waveform, 512)
window = dsp.randchoose(['sine', 'tri', 'hann'])
window = dsp.wavetable(window, 512)
pulsewidth = dsp.rand(0.1, 1)
modFreq = dsp.rand(0.1, 10.0) / dsp.fts(length)
numgrains = length / 32
numpoints = dsp.randint(2, 6)
apoints = [0] + [dsp.rand(0, 1) for p in range(numpoints - 2)] + [0]
ppoints = [dsp.rand(0, 1) for p in range(numpoints)]
e = dsp.breakpoint(apoints, numgrains)
p = dsp.breakpoint(ppoints, numgrains)
mod = dsp.wavetable('random', 512)
modRange = dsp.rand(0, 0.001)
print ' ', round(freq, 2), round(modRange, 3), round(modFreq, 3)
layer = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, 0.1)
layer = dsp.split(layer, dsp.flen(layer) / numgrains)
layer = layer[:numgrains]
layer = [ dsp.pan(dsp.amp(layer[i], e[i]), p[i]) for i in range(numgrains) ]
layer = ''.join(layer)
layers += [ layer ]
out = dsp.mix(layers)
return out
def gamutScale():
num_notes = dsp.randint(3, 6)
scale = [
dsp.randchoose([1, 2, 3, 4, 5, 6, 7, 8]) for _ in range(num_notes)
]
freqs = tune.fromdegrees(scale, octave=octave, root=key)
return freqs
def makeStab(length, i):
chord = tune.fromdegrees([ dsp.randchoose([1,4,5,8]) for _ in range(dsp.randint(2,4)) ], octave=3, root=key)
stab = rhodesChord(length, chord, dsp.rand(0.5, 0.75))
stab = dsp.taper(stab, 40)
stab = dsp.fill(stab, length, silence=True)
return stab
def bendit(out=''):
if bbend == True:
bendtable = dsp.randchoose([
'impulse', 'sine', 'line', 'phasor', 'cos',
'impulse'
])
lowbend = dsp.rand(0.8, 0.99)
highbend = dsp.rand(1.0, 1.25)
else:
bendtable = 'sine'
lowbend = 0.99
# lowbend = 0.75
highbend = 1.01
# highbend = 1.5
out = dsp.split(out, 441)
freqs = dsp.wavetable(bendtable, len(out))
freqs = [
math.fabs(f) * (highbend - lowbend) + lowbend
for f in freqs
]
out = [
dsp.transpose(out[i], freqs[i])
for i in range(len(out))
]
return ''.join(out)
def play(ctl):
param = ctl.get("param")
# lpd = ctl.get('midi').get('lpd')
# pc = ctl.get('midi').get('pc')
# pc.setOffset(111)
# r = dsp.read('sounds/roll.wav').data
r = dsp.read("sounds/pills.wav").data
r = dsp.fill(r, dsp.stf(3))
# tr = pc.get(10, low=0.125, high=4)
tr = dsp.rand(0.125, 4)
r = dsp.transpose(r, dsp.rand(tr * 0.25, tr * 2))
# r = dsp.amp(r, pc.get(1, low=0, high=10))
r = dsp.amp(r, dsp.rand(0, 10))
reverse = dsp.randchoose([True, False])
# numgrains = pc.geti(2, low=5, high=20)
numgrains = dsp.randint(5, 20)
# numlayers = pc.geti(3, low=5, high=50)
numlayers = dsp.randint(5, 50)
# minlen = lpd.get(9, low=10, high=100)
minlen = dsp.rand(10, 100)
# lenranges = (lpd.get(9, low=10, high=50), lpd.get(9, low=50, high=500))
lenranges = (dsp.rand(10, 50), dsp.rand(50, 500))
out = fx.spider(r, numlayers, numgrains, minlen, lenranges, reverse)
# out = dsp.mix([out, dsp.env(r, 'sine')])
return out
def makeRhodes(length, beat, freqs):
root = tune.ntf(key, 2)
for i, freq in enumerate(freqs):
if freq > root * 2.5:
freqs[i] = freq * 0.5
chord = [keys.rhodes(length, freq, dsp.rand(0.4, 0.6)) for freq in freqs]
chord = dsp.randshuffle(chord)
pause = 0
for i, c in enumerate(chord):
pause = pause + (dsp.randint(1, 4) * beat)
c = dsp.pan(c, dsp.rand())
chord[i] = dsp.pad(dsp.fill(c, length - pause), pause, 0)
chord = dsp.mix(chord)
chord = dsp.split(chord, dsp.flen(chord) / 16)
chord = dsp.randshuffle(chord)
chord = [dsp.env(ch, "phasor") for ch in chord]
chord = [
dsp.mix(
[
dsp.amp(dsp.pan(grain, dsp.rand()), dsp.rand(0.1, 0.8)),
dsp.amp(dsp.pan(dsp.randchoose(chord), dsp.rand()), dsp.rand(0.1, 0.8)),
]
)
for grain in chord
]
chord = "".join(chord)
return chord
def makeKick(length, i):
k = dsp.randchoose([ kickhard, kicksoft ])
k = dsp.mix([ k, dsp.env(sock, 'phasor') ])
if dsp.rand() > 0.4:
k = dsp.env(k, 'phasor')
return dsp.fill(k, length, silence=True)
def iowa(inst, freq=440, wildcard=''):
midi_note = tune.ftomi(freq)
files = getMatches(inst, midi_note, wildcard)
filename = dsp.randchoose(files)
return dsp.read(filename).data
def makeStab(length, i):
freqs = tune.fromdegrees([ dsp.randchoose([1,2,3,4,5,6,8]) for _ in range(dsp.randint(2,4)) ], octave=3, root=key)
stab = chord(length, freqs, dsp.rand(0.25, 0.75))
stab = dsp.taper(stab, 40)
stab = dsp.fill(stab, length, silence=True)
return stab
def play(ctl):
freqs = tune.fromdegrees([1,3,6,8,9], octave=4, root='a')
freq = dsp.randchoose(freqs)
length = dsp.stf(dsp.rand(3, 5))
out = keys.rhodes(length, freq)
return out
def play(args):
length = dsp.stf(0.2)
volume = 0.2
octave = 2
notes = ['d', 'a']
quality = tune.major
waveform = 'sine'
ratios = tune.terry
wtypes = ['sine', 'phasor', 'line', 'saw']
for arg in args:
a = arg.split(':')
if a[0] == 't':
length = dsp.stf(float(a[1]))
if a[0] == 'v':
volume = float(a[1]) / 100.0
if a[0] == 'o':
octave = int(a[1])
if a[0] == 'n':
notes = a[1].split('.')
if a[0] == 'q':
if a[1] == 'M':
quality = tune.major
elif a[1] == 'm':
quality = tune.minor
else:
quality = tune.major
if a[0] == 'tr':
ratios = getattr(tune, a[1], tune.terry)
harm = range(1, 12)
layers = []
for note in notes:
freq = tune.ntf(note, octave, ratios)
#tonic = dsp.env(dsp.amp(dsp.tone(length, freq, 'sine2pi'), 0.2), 'phasor') * 500
tones = []
for t in range(4):
angles = dsp.breakpoint([ freq * dsp.randchoose(harm) for f in range(dsp.randint(2, 20)) ], 100)
angles = [ dsp.env(dsp.tone(length, a, 'sine2pi'), 'sine', amp=0.2) for a in angles ]
tones += [ ''.join(angles) ]
#layer = dsp.benv(dsp.mix(tones), [ dsp.rand(0.1, 0.7) for i in range(dsp.randint(5, 30)) ])
layers += [ dsp.mix(tones) ]
#layers += [ dsp.mix([layer, tonic]) ]
#layers += [ layer ]
out = dsp.mix(layers)
return dsp.amp(out, volume)
def play(voice_id):
bpm = config('bpm')
key = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
beat = dsp.bpm2frames(bpm)
beat = beat / 4
glitch = False
alias = False
nbeats = P(voice_id, 'multiple', dsp.randchoose([8, 16]))
gs = ['gC1', 'gC2']
g = dsp.randchoose(gs)
n = dsp.read('sounds/%s.wav' % g).data
# speeds = [1, 1.25, 1.5, 1.666, 2, 4]
speeds = [1, 1.25, 1.5, 2, 3, 4, 6, 8, 16]
root = tune.ntf('c')
target = tune.ntf(key)
n = dsp.transpose(n, target / root)
n = dsp.fill(n, dsp.stf(20))
n = dsp.transpose(n, dsp.randchoose(speeds))
n = dsp.split(n, beat)
n = dsp.randshuffle(n)
n = n[:nbeats + 1]
if alias:
n = [dsp.alias(nn) for nn in n]
n = [dsp.amp(nn, dsp.rand(0.1, 0.75)) for nn in n]
n = [dsp.pan(nn, dsp.rand()) for nn in n]
n = ''.join(n)
out = n
if glitch:
out = dsp.vsplit(out, dsp.mstf(dsp.rand(80, 140)), dsp.mstf(500))
out = dsp.randshuffle(out)
out = ''.join(out)
return out
def chirp(s):
length = dsp.flen(s)
#chirps = [ dsp.chirp(dsp.randint(10, 10000), 60, 5000, dsp.randint(1,100)) for c in range(100) ]
chirps = [ dsp.chirp(
numcycles=dsp.randint(50, 1000),
lfreq=dsp.rand(9000, 12000),
hfreq=dsp.rand(14000, 20000),
length=441 + (i * 41),
etype=dsp.randchoose(['gauss', 'sine', 'line', 'phasor']),
wform=dsp.randchoose(['sine', 'tri', 'phasor', 'line']))
for i in range(100) ]
chirps = [ dsp.pan(c, dsp.rand()) for c in chirps ]
chirps = ''.join(chirps)
return dsp.fill(chirps, length)
def play(voice_id):
bpm = config('bpm')
key = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
beat = dsp.bpm2frames(bpm)
beat = beat / 4
glitch = False
alias = False
nbeats = P(voice_id, 'multiple', dsp.randchoose([8, 16]))
gs = ['gC1', 'gC2']
g = dsp.randchoose(gs)
n = dsp.read('sounds/%s.wav' % g).data
# speeds = [1, 1.25, 1.5, 1.666, 2, 4]
speeds = [1, 1.25, 1.5, 2, 3, 4, 6, 8, 16]
root = tune.ntf('c')
target = tune.ntf(key)
n = dsp.transpose(n, target / root)
n = dsp.fill(n, dsp.stf(20))
n = dsp.transpose(n, dsp.randchoose(speeds))
n = dsp.split(n, beat)
n = dsp.randshuffle(n)
n = n[:nbeats + 1]
if alias:
n = [ dsp.alias(nn) for nn in n ]
n = [ dsp.amp(nn, dsp.rand(0.1, 0.75)) for nn in n ]
n = [ dsp.pan(nn, dsp.rand()) for nn in n ]
n = ''.join(n)
out = n
if glitch:
out = dsp.vsplit(out, dsp.mstf(dsp.rand(80, 140)), dsp.mstf(500))
out = dsp.randshuffle(out)
out = ''.join(out)
return out
def choose_interval(lastroot):
interval = dsp.randchoose([3, 4, -3, -4])
if interval + lastroot >= 1 and interval + lastroot <= 12 and interval + lastroot != 2 and interval + lastroot != 9:
nextroot = lastroot + interval
else:
nextroot = choose_interval(lastroot)
return nextroot
def makePulse(length, i):
freqs = tune.fromdegrees([ dsp.randchoose([1,2,3,4,5,6,8]) for _ in range(dsp.randint(2,4)) ], octave=2, root=key)
pulse = chord(length, freqs, dsp.rand(0.5, 0.75))
pulse = dsp.taper(pulse, 40)
pulse = dsp.amp(pulse, dsp.rand(0.5, 1))
pulse = dsp.fill(pulse, length, silence=True)
return pulse
def play(params={}):
volume = params.get('volume', 100.0)
volume = volume / 100.0 # TODO: move into param filter
volume = volume * 0.25
length = params.get('length', 40)
env = params.get('envelope', False)
wii = params.get('wii', False)
speed = params.get('speed', False)
numcycles = dsp.randint(10, 524)
# Make breakpoint env with 2-10 vals between 0.1 and 1.0
curve_a = dsp.breakpoint([1.0] + [dsp.rand(0.1, 1.0) for r in range(dsp.randint(2, 10))] + [0], numcycles)
# Make wavetable with single cycle from given wave types
curve_types = ['vary', 'phasor', 'sine', 'cos', 'impulse']
curve_b = dsp.wavetable(dsp.randchoose(curve_types), numcycles)
# Make pan curve - always cosine
pan = dsp.wavetable('cos', numcycles)
# Multiply breakpoint curve with simple wavetable
wtable = [ curve_a[i] * curve_b[i] for i in range(numcycles) ]
# Scale to max frequency
wtable = [ (f * 19000) + length for f in wtable ]
# Possible osc wavetypes
wtypes = ['impulse', 'tri', 'cos', 'sine2pi', 'vary']
if wii is True:
out = [ dsp.pan(dsp.cycle(wtable[i], dsp.randchoose(wtypes)), pan[i]) for i in range(numcycles) ]
else:
wtype = dsp.randchoose(wtypes)
out = [ dsp.pan(dsp.cycle(wtable[i], wtype), pan[i]) for i in range(numcycles) ]
out = dsp.amp(''.join(out), volume)
if speed != False and speed > 0.0:
out = dsp.transpose(out, speed)
if env != False:
out = dsp.env(out, env)
return out
def play(voice_id):
bpm = C('bpm')
beat = dsp.bpm2frames(bpm)
volume = P(voice_id, 'volume', default=1.0)
crinkle = dsp.read('sounds/s/crinkle.wav').data
glass1 = dsp.read('sounds/s/glass1.wav').data
glass2 = dsp.read('sounds/s/glass2.wav').data
toys = dsp.read('sounds/s/rolling.wav').data
c = dsp.vsplit(crinkle, dsp.mstf(10), dsp.stf(3))
c = dsp.randshuffle(c)
c = c[:40]
c = [dsp.pan(cc, dsp.rand()) for cc in c]
c = [dsp.env(cc, 'sine') for cc in c]
c = [dsp.transpose(cc, dsp.rand(0.25, 0.5)) for cc in c]
t = dsp.vsplit(toys, dsp.mstf(10), dsp.stf(1))
t = dsp.randshuffle(t)
t = t[:40]
t = [dsp.amp(tt, dsp.rand(0.1, 0.8)) for tt in t]
t = [dsp.pan(tt, dsp.rand(0, 1)) for tt in t]
t = [dsp.env(tt, 'sine') for tt in t]
t = [dsp.transpose(tt, 0.5) for tt in t]
g = dsp.vsplit(glass2, dsp.mstf(1), dsp.mstf(100))
g = dsp.randshuffle(g)
g = g[:40]
g = [dsp.amp(gg, dsp.rand(0.35, 0.95)) for gg in g]
g = [dsp.transpose(gg, dsp.rand(0.5, 1.75)) for gg in g]
g = [gg * dsp.randint(1, 8) for gg in g]
things = [c, t, g]
out = [
dsp.mix([
dsp.randchoose(dsp.randchoose(things))
for l in range(dsp.randint(2, 4))
]) for i in range(4)
]
out = ''.join(out)
dsp.log('voice %s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
return out
def makePulse(length, i):
chord = tune.fromdegrees([ dsp.randchoose([1,4,5,8]) for _ in range(dsp.randint(2,4)) ], octave=2, root=key)
pulse = rhodesChord(length, chord, dsp.rand(0.5, 0.75))
#pulse = dsp.mix([ pulse, kick ])
pulse = dsp.taper(pulse, 40)
pulse = dsp.amp(pulse, dsp.rand(0.9, 1.5))
pulse = dsp.fill(pulse, length, silence=True)
return pulse
def bln(length, low=3000.0, high=7100.0, wform="sine2pi"):
wforms = ["tri", "sine2pi", "impulse", "cos2pi"]
outlen = 0
cycles = ""
while outlen < length:
cycle = dsp.cycle(dsp.rand(low, high), dsp.randchoose(wforms))
outlen += len(cycle)
cycles += cycle
return cycles
def play(voice_id):
tel = bot.getTel()
degrees = [ dsp.randchoose([1, 2, 3, 4, 5, 6, 7, 8]) for f in range(dsp.randint(2, 6)) ]
octave = dsp.randint(1, 4)
freqs = tune.fromdegrees(degrees, root='c', octave=octave, ratios=tune.just)
out = ''
freq = dsp.randchoose(freqs)
volume = dsp.rand(0.5, 0.8)
length = dsp.randint(dsp.mstf(20), dsp.mstf(30))
for p in range(dsp.randint(20, 100)):
pulsewidth = dsp.rand(0.5, 1)
mod = dsp.breakpoint([ dsp.rand(0, 1) for b in range(4) ], 512)
window = dsp.breakpoint([0] + [ dsp.rand(0, 1) for b in range(10) ] + [0], 512)
waveform = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for b in range(20) ] + [0], 512)
modRange = 0.01
modFreq = dsp.rand(0.0001, 5)
t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
t = dsp.pad(t, 0, length * 3)
t = dsp.env(t, 'sine')
out += t
out = dsp.env(out, 'sine')
out = dsp.pan(out, dsp.rand(0, 1))
dsp.log('')
dsp.log('drone')
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def play(ctl):
lpd = ctl.get('midi').get('lpd')
def rain(snd, freqs):
layers = []
for freq in freqs:
#layer = dsp.pine(snd, dsp.flen(snd) * 16, freq)
layer = dsp.pan(snd, dsp.rand())
layer = dsp.amp(layer, 0.5)
layer = dsp.alias(layer)
layers += [ layer ]
return dsp.mix(layers)
wf = dsp.breakpoint([0] + [ dsp.rand(-1,1) for w in range(lpd.geti(7, low=4, high=200, default=0)) ] + [0], 512)
win = dsp.wavetable('sine', 512)
mod = [ dsp.rand(0, 1) for m in range(512) ]
modr = lpd.get(5, low=0.01, high=1, default=1)
modf = dsp.rand(0.5, 2)
amp = lpd.get(3, low=0, high=0.5, default=0)
length = dsp.mstf(lpd.get(2, low=150, high=500))
pw = lpd.get(1, low=0.1, high=1, default=1)
freqs = tune.fromdegrees([1,3,5], octave=2, root='c')
freq = dsp.randchoose(freqs) / 4.0
#o = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp)
#o = dsp.read('/home/hecanjog/sounds/guitarpluck.wav').data
o = dsp.read('sounds/rhodes.wav').data
o = dsp.transpose(o, dsp.randchoose([0.5, 1, 2, 1.5, 3]))
o = dsp.fill(o, dsp.stf(dsp.rand(0.1, 2)))
out = rain(o, freqs)
#out = dsp.env(out, 'random')
return out
def fracture(snd):
numpoints = dsp.randint(3, 20)
poscurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0],
numpoints)
poscurve = [p * (dsp.flen(snd) - dsp.mstf(210)) for p in poscurve]
lencurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0],
numpoints)
lencurve = [l * dsp.mstf(200) + dsp.mstf(10) for l in lencurve]
pancurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0],
numpoints)
prepadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0],
numpoints)
prepadcurve = [int(p * dsp.mstf(20)) for p in prepadcurve]
postpadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0],
numpoints)
postpadcurve = [int(p * dsp.mstf(20)) for p in postpadcurve]
speeds = [1.0, 2.0, 0.5, 0.75]
grains = [dsp.cut(snd, poscurve[i], lencurve[i]) for i in range(numpoints)]
grains = [dsp.pan(grains[i], pancurve[i]) for i in range(numpoints)]
grains = [dsp.env(grain, 'gauss', True) for grain in grains]
grains = [dsp.transpose(grain, dsp.randchoose(speeds)) for grain in grains]
grains = [
dsp.pad(grains[i], prepadcurve[i], postpadcurve[i])
for i in range(numpoints)
]
for i in range(numpoints):
if dsp.randint(0, 3) == 0:
grains[i] = slurp(grains[i])
etypes = ['line', 'phasor', 'tri', 'sine', 'gauss']
snd = dsp.env(''.join(grains), dsp.randchoose(etypes))
snd = dsp.pad(snd, 0, dsp.mstf(dsp.rand(100, 400)))
return snd
def play(voice_id):
reload(keys)
bpm = config('bpm')
root = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
scale = [1,5,8]
if dsp.rand() > 0.5:
scale = reversed(scale)
freqs = tune.fromdegrees(scale, root=root, octave=dsp.randint(1, 3), ratios=ratios, scale=quality)
freqs = dsp.rotate(freqs, dsp.randint(0, len(freqs)))
out = ''
length = int(dsp.bpm2frames(bpm) * dsp.randchoose([0.25, 0.5, 1]) * 0.5)
length = dsp.bpm2frames(bpm) * 4
length = dsp.stf(dsp.rand(1, 8))
for n in range(dsp.randint(1, 3)):
amp = dsp.rand(0.3, 0.65)
freq = dsp.randchoose(freqs)
freq = freqs[n%len(freqs)]
b = keys.chippy(length=length, freq=freq, amp=amp)
b = dsp.split(b, 100)
oenvs = dsp.breakpoint([0,0,0,0] + [ dsp.rand() for i in range(len(b) / 10) ], len(b))
opans = dsp.breakpoint([dsp.rand(0.4, 0.6)] + [ dsp.rand() for i in range(len(b) / 100) ] + [0.5], len(b))
b = [ dsp.amp(b[i], oenvs[i]) for i in range(len(b)) ]
b = [ dsp.pan(b[i], opans[i]) for i in range(len(b)) ]
b = ''.join(b)
#b = dsp.env(b, 'phasor')
b = dsp.env(b, 'sine')
out += b
return out
def makeStab(length, i):
freqs = tune.fromdegrees([
dsp.randchoose([1, 2, 3, 4, 5, 6, 8]) for _ in range(dsp.randint(2, 4))
],
octave=3,
root=key)
stab = chord(length, freqs, dsp.rand(0.25, 0.75))
stab = dsp.taper(stab, 40)
stab = dsp.fill(stab, length, silence=True)
return stab
def makePulse(length, i):
freqs = tune.fromdegrees([
dsp.randchoose([1, 2, 3, 4, 5, 6, 8]) for _ in range(dsp.randint(2, 4))
],
octave=2,
root=key)
pulse = chord(length, freqs, dsp.rand(0.5, 0.75))
pulse = dsp.taper(pulse, 40)
pulse = dsp.amp(pulse, dsp.rand(0.5, 1))
pulse = dsp.fill(pulse, length, silence=True)
return pulse
def makeGrains(out, length=None, env=None):
envs = ['tri', 'line', 'flat', 'sine', 'hann']
out = dsp.vsplit(out, dsp.mstf(20), dsp.mstf(90))
out = [dsp.env(grain, 'hann') for grain in out]
out = [dsp.pan(grain, dsp.rand()) for grain in out]
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.env(out, dsp.randchoose(envs))
return out
def nextChord(last):
degs = dsp.randshuffle(last)[:dsp.randint(1, 2)]
for deg in degs:
newdeg = deg + dsp.randchoose([-1, 1])
if newdeg == 0:
newdeg = 1
elif newdeg > 15:
newdeg = 15
last[last.index(deg)] = newdeg
return last
def makeHats(length, wobble):
out = Tracks()
onsets = makeOnsets(length, wobble, 1, 16, True)
for onset in onsets:
out.add(h, onset)
out = out.mix()
out = dsp.split(out, dsp.flen(out) / dsp.randchoose([2, 3, 4]))
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.fill(out, length, silence=False)
return dsp.taper(out, 40)
def play(voice_id):
bpm = config('bpm')
root = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
bendfactor = 0.05
# bendfactor = 0
bdiv = 4
bdiv *= dsp.randchoose([16, 24, 32])
loctave = 1
hoctave = 4
si = 32 * dsp.randint(1, 2)
beat = dsp.bpm2frames(bpm) / bdiv
y = [easeOutQuad(float(i), 0, 1, si) for i in range(si)]
z = [easeOutQuad(float(i), 0, 1, si) for i in reversed(range(si))]
freqs = tune.fromdegrees([1, 2, 3, 4, 5, 6, 7, 8],
root=root,
octave=dsp.randint(loctave, hoctave),
ratios=ratios,
scale=quality)
freqs = freqs[:dsp.randint(1, len(freqs))]
if dsp.rand() > 0.5:
freqs = [f for f in reversed(freqs)]
freqs = dsp.rotate(freqs, dsp.randint(0, len(freqs)))
y = y + z
y = [dsp.mstf(v * beat) + dsp.mstf(2) for v in y]
x = range(len(y))
def make(length, freq):
freq *= dsp.rand(1 - (bendfactor / 2.0), 1 + (bendfactor / 2.0))
out = keys.chippy(length=int(length * dsp.rand(0.01, 0.4)),
freq=freq,
amp=0.7)
out = dsp.env(out, 'phasor')
out = dsp.pad(out, 0, length - dsp.flen(out))
return out
out = [make(v, freqs[i % len(freqs)]) for i, v in enumerate(y)]
out = ''.join(out)
out = dsp.pan(out, dsp.rand(0, 1))
return out
def clap1(beat):
c = dsp.read('sounds/mikeclap.wav').data
c = dsp.transpose(c, dsp.rand(1, 2.5))
c = dsp.fill(c, dsp.mstf(dsp.rand(10, 100)))
c = dsp.env(c, 'phasor')
c = dsp.amp(c, dsp.rand(1, 3))
c = dsp.pad(c, 0, beat - dsp.flen(c))
blen = beat / dsp.randchoose([1, 2])
c = dsp.pad(c, blen, 0)
c *= 4
return c
def play(ctl):
midi = ctl.get('midi')
midi.setOffset(111)
pw = midi.get(1, low=0.01, high=1)
scale = [1, 2, 3, 6, 9]
scale = tune.fromdegrees(scale, octave=midi.geti(4, low=0, high=4))
freq = dsp.randchoose(scale)
length = dsp.stf(midi.get(2, low=0.1, high=8) * dsp.rand(0.5, 1.5))
wf = dsp.wavetable('sine2pi')
win = dsp.wavetable('sine')
mod = [dsp.rand(0, 1) for m in range(1000)]
modr = midi.get(5, low=0, high=0.3)
modf = midi.get(6, low=0.001, high=10)
amp = midi.get(3, low=0, high=1)
out = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp)
out = dsp.env(out, dsp.randchoose(['sine', 'tri']))
out = dsp.pan(out, dsp.rand())
return out
def makeClaps(length, wobble):
out = Tracks()
onsets = makeOnsets(length, wobble, 2, 8, True)
for onset in onsets:
clap = dsp.stretch(c,
int(dsp.flen(c) * log.get(1, 10)),
grain_size=dsp.randint(20, 120))
out.add(clap, onset)
out = out.mix()
out = dsp.split(out, dsp.flen(out) / dsp.randchoose([2, 3, 4]))
out = [dsp.taper(o, 20) for o in out]
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.fill(out, length, silence=False)
return dsp.taper(out, 40)
def tempoPath(nsegs):
#maxms = dsp.rand(300, 500)
#minms = dsp.rand(1, 100)
minms = 1
maxms = 500
wavetypes = ['hann', 'sine', 'vary']
out = []
for _ in range(nsegs):
seglen = dsp.randint(20, 100)
seg = dsp.wavetable(dsp.randchoose(wavetypes), seglen)
# pull out a randomly selected subsegment of the curve
sublen = seglen / dsp.randint(2, 5)
segstart = dsp.randint(0, seglen - sublen)
segend = segstart + sublen
seg = seg[segstart:segend]
out += [[dsp.mstf(abs(s) * (maxms - minms) + minms) for s in seg]]
return out
def play(voice_id):
bpm = config('bpm')
root = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
beat = dsp.bpm2frames(bpm)
length = dsp.randint(dsp.stf(1), dsp.stf(3))
wav = dsp.breakpoint([0] + [dsp.rand(-1, 1) for w in range(10)] + [0], 512)
win = dsp.wavetable('sine', 512)
mod = dsp.wavetable('vary', 512)
root = dsp.randchoose(tune.fromdegrees([1, 3, 5, 8], octave=0, root='a'))
pw = dsp.rand(0.1, 1)
amp = dsp.rand(0.5, 1.2)
mFreq = 0.01 / dsp.fts(length)
out = dsp.pulsar(root, length, pw, wav, win, mod, 0.05, mFreq, amp)
# out = dsp.env(out, 'vary')
out = dsp.vsplit(out, dsp.mstf(1), dsp.mstf(500))
out = dsp.randshuffle(out)
out = [dsp.pad(o, 0, dsp.randint(0, 4410)) for o in out]
out = [dsp.pan(o, dsp.rand()) for o in out]
out = [dsp.alias(o) for o in out]
out = [o * dsp.randint(1, 30) for o in out]
out = [dsp.env(o, 'random') for o in out]
out = [dsp.amp(o, dsp.rand(0.9, 1.5)) for o in out]
out = ''.join(out)
return out
def play(ctl):
lpd = ctl.get('midi').get('lpd')
param = ctl.get('param')
#pc.setOffset(111)
chord_index = param.get('chord_index', default=0)
if lpd.get(36, default=1) < 1:
dsp.log(lpd.get(36))
param.set('chord_index', chord_index + 1)
areas = ['high', 'pitch', 'mid', 'low']
area = lpd.geti(23, low=0, high=len(areas), default=len(areas))
if area == len(areas):
area = dsp.randchoose(areas)
else:
area = areas[area]
param.set('wash-area', area, throttle=1)
param.set('wash-area', 'high', throttle=1)
return dsp.pad('', 0, dsp.mstf(100))
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
lows = [dsp.rand(20, freq) for freq in highs]
amps = dsp.breakpoint(
[dsp.rand(0.1, 0.3) for _ in range(npulses / 50)], npulses)
pans = dsp.breakpoint([dsp.rand(0, 1) for _ in range(npulses / 10)],
npulses)
lengths = [
dsp.mstf(l) for l in dsp.breakpoint(
[dsp.rand(1, 30) for _ in range(npulses / 10)], npulses)
]
for high, low, amp, pan, length in zip(highs, lows, amps, pans,
lengths):
p = dsp.bln(length,
low,
high,
wform=dsp.randchoose(['hann', 'sine2pi', 'tri']))
p = dsp.env(p, 'hann')
p = dsp.taper(p, 20)
p = dsp.amp(p, amp)
p = dsp.pan(p, pan)
layer += p
layers += [layer]
freqs = tune.fromdegrees([dsp.randint(1, 9) for _ in range(nlayers)],
octave=1,
root='a')
for i, freq in enumerate(freqs):
layers[i] = dsp.pine(layer, dsp.flen(layer) * 10, freq)
def play(voice_id):
bpm = config('bpm')
beat = dsp.bpm2frames(bpm)
dsl = P(voice_id, 'drum', '["c","k","h"]')
dsp.log(dsl)
dsl = json.loads(dsl)
def hat(beat):
length = beat * 4
nbeats = 16
blen = length / nbeats
out = ''
for b in range(nbeats):
h = dsp.transpose(tape1, 9)
h = dsp.fill(h, dsp.mstf(dsp.rand(1, 20)))
h = dsp.env(h, 'phasor')
h = dsp.amp(h, dsp.rand(0, 0.8))
h = dsp.pad(h, 0, blen - dsp.flen(h))
out += h
out *= 8
return out
def kick(beat):
out = drums.sinekick(length=beat, amp=dsp.rand(0.8, 1))
out = dsp.pad(out, 0, beat * dsp.randint(1, 2))
out *= 2
return out
def clap1(beat):
c = dsp.read('sounds/mikeclap.wav').data
c = dsp.transpose(c, dsp.rand(1, 2.5))
c = dsp.fill(c, dsp.mstf(dsp.rand(10, 100)))
c = dsp.env(c, 'phasor')
c = dsp.amp(c, dsp.rand(1, 3))
c = dsp.pad(c, 0, beat - dsp.flen(c))
blen = beat / dsp.randchoose([1, 2])
c = dsp.pad(c, blen, 0)
c *= 4
return c
def clap2(beat):
nlens = [
beat * 2,
beat,
beat / 2,
]
# length of pattern (in beats)
nbeats = dsp.randint(10, 15)
# beat lengths (from a set of bpm-derived note lengths defined in the nlens list)
blens = [dsp.randchoose(nlens) for b in range(nbeats)]
out = ''
# synthesize the tones
for i in range(nbeats):
beat = dsp.transpose(dsp.randchoose([c1, c2]),
dsp.rand(0.25, 40.0))
beat = dsp.pad(beat, 0, blens[i] - dsp.flen(beat))
beat = dsp.amp(beat, dsp.rand(1, 4))
# add it to the output
out += beat
return out
all = []
if 'c' in dsl:
clapper = dsp.randchoose([clap1, clap2])
all += [clapper(beat)]
if 'k' in dsl:
all += [kick(beat)]
if 'h' in dsl:
all += [hat(beat)]
out = dsp.mix(all)
# out = dsp.vsplit(out, dsp.mstf(dsp.rand(8, 140)), dsp.mstf(500))
# out = dsp.randshuffle(out)
# out = ''.join(out)
out = dsp.vsplit(out, 10, 1000)
out = [dsp.amp(o, dsp.rand(0, 4)) for o in out]
out = [dsp.env(o, 'random') for o in out]
out = [dsp.transpose(o, dsp.rand(0.25, 1)) for o in out]
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.pine(out, int(dsp.flen(out) * dsp.rand(1.5, 4)),
dsp.rand(10, 2000), dsp.randint(0, 2), dsp.rand(1, 3),
dsp.randint(0, 2), dsp.rand(1, 3))
out = dsp.amp(out, 0.65)
glass = dsp.read('sounds/s/glass2.wav').data
glass = dsp.vsplit(glass, dsp.mstf(1), dsp.mstf(100))
glass = dsp.randshuffle(glass)
# glass = [ dsp.pad(g, 0, dsp.randint(10, 1000)) for g in glass ]
# glass = [ dsp.transpose(g, dsp.rand(0.5, 1.5)) * dsp.randint(1, 3) for g in glass ]
glass = ''.join(glass)
glass = dsp.fill(glass, dsp.flen(out))
out = dsp.mix([out, glass])
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 nextChord(name):
name = stripChord(name)
return dsp.randchoose(progressions[name])
def makeRhodes(length, beat, freqs):
root = tune.ntf(key, 2)
for i, freq in enumerate(freqs):
if freq > root * 2.5:
freqs[i] = freq * 0.5
chord = [ keys.rhodes(length, freq, dsp.rand(0.4, 0.6)) for freq in freqs ]
chord = dsp.randshuffle(chord)
pause = 0
for i, c in enumerate(chord):
pause = pause + (dsp.randint(1, 4) * beat)
c = dsp.pan(c, dsp.rand())
chord[i] = dsp.pad(dsp.fill(c, length - pause), pause, 0)
chord = dsp.mix(chord)
chord = dsp.split(chord, dsp.flen(chord) / 16)
chord = dsp.randshuffle(chord)
chord = [ dsp.env(ch, 'phasor') for ch in chord ]
chord = [ dsp.mix([ dsp.amp(dsp.pan(grain, dsp.rand()), dsp.rand(0.1, 0.8)), dsp.amp(dsp.pan(dsp.randchoose(chord), dsp.rand()), dsp.rand(0.1, 0.8)) ]) for grain in chord ]
chord = ''.join(chord)
return chord
