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 smear(input, mingrain=2205, maxgrain=4410, waveform='hann', spread=0.1, drift=0.05, minpan=0.0, maxpan=1.0, minamp=0.0, maxamp=1.0):
out = dsp.vsplit(input, mingrain, maxgrain)
out = [ dsp.amp(grain, dsp.rand(minamp, maxamp)) for grain in out ]
out = [ dsp.env(grain, waveform) for grain in out ]
out = [ dsp.pan(grain, dsp.rand(minpan, maxpan)) for grain in out ]
drift_delta = drift / 2.0
minspeed = 1.0 - drift_delta
maxspeed = 1.0 + drift_delta
out = [ dsp.transpose(grain, dsp.rand(minspeed, maxspeed)) for grain in out ]
num_shuffled_grains = int(len(out) * spread)
# Pull a random set of grains
shuffled_grains = []
for i in range(num_shuffled_grains):
index = dsp.randint(0, len(out) - 1)
shuffled_grains += [ out.pop(index) ]
# Insert them back into random positions
for grain in shuffled_grains:
index = dsp.randint(0, len(out) - 1)
out.insert(index, grain)
out = ''.join(out)
return out
def makeSnare(length, i, amp):
s = dsp.cut(snare, 0, dsp.randint(dsp.mstf(40), dsp.flen(snare)))
s = dsp.alias(s, dsp.randint(4, 12))
s = dsp.taper(s)
s = dsp.fill(s, length, silence=True)
s = dsp.amp(s, dsp.rand(2, 4))
return s
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 bass_and_lead(length, pos, total_length):
numbeats = int(length//BEAT)
maxbeats = dsp.randint(2, 16)
layers = []
def bass(amp, length, oct=2):
if amp == 0:
return dsp.buffer(length=length)
bass_note = dsp.choice(scale) * 0.25
stack = Waveset(rmx, limit=dsp.randint(5, 20), offset=dsp.randint(0, 100))
stack.normalize()
out = oscs.Pulsar2d(stack, windows=['sine'], freq=bass_note).play(length) * dsp.rand(0.02, 0.2)
out = fx.lpf(out, bass_note*2)
return out.env('hannout').taper(dsp.MS*10)
if dsp.rand() > 0.5:
basses = bass(0.5, length, 1)
else:
bpat = drums.eu(numbeats, maxbeats)
basses = drums.make(bass, bpat, [BEAT]*numbeats)
layers += [ basses ]
lead_note = dsp.choice(scale)
stack = Waveset(rmx, limit=dsp.randint(5, 20), offset=dsp.randint(0, 100))
stack.normalize()
lead = oscs.Pulsar2d(stack, windows=['tri'], freq=lead_note*2, pulsewidth=dsp.win('rnd', 0.1, 1)).play(length/dsp.rand(1,5)).env('hannout').taper(0.01) * dsp.rand(0.02, 0.2)
layers += [ lead ]
return fx.norm(dsp.mix(layers), 1)
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 roll(snd, length=None, numlayers=2, minlen=10, maxlen=80, env=True, bend=True):
layers = []
for _ in range(numlayers):
if length is None:
numbeats = dsp.randint(20, 50)
else:
numbeats = length / dsp.mstf(minlen)
lengths = dsp.breakpoint([ dsp.rand(minlen, maxlen) for _ in range(dsp.randint(5, numbeats/2)) ], numbeats)
layer = ''
for l in lengths:
layer += dsp.fill(snd, dsp.mstf(l), silence=True)
if bend:
layer = fx.bend(layer, [ dsp.rand(0, 1) for _ in range(dsp.randint(5, 20)) ], dsp.rand(0.02, 1))
if env:
layer = fx.penv(layer)
layers += [ layer ]
out = dsp.mix(layers)
out = dsp.fill(out, length)
return out
def singit(lyrics, mult):
words = text2wave(lyrics)
root = config('key')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
pitches = [dsp.randint(1, 9) for i in range(dsp.randint(2, 4))]
pitches = tune.fromdegrees(pitches,
octave=dsp.randint(1, 4),
root=root,
ratios=ratios,
scale=quality)
return words
sings = [
dsp.pine(words,
dsp.flen(words) * mult, pitch) for pitch in pitches
]
sings = dsp.mix(sings)
# sings = sox("sox %s %s tempo 1.0", sings)
return sings
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 makeArps(seg, oct=3, reps=4):
arp_degrees = [1,2,3,5,8,9,10]
if dsp.randint(0,1) == 0:
arp_degrees.reverse()
arp_degrees = rotate(arp_degrees, vary=True)
arp_notes = tune.fromdegrees(arp_degrees[:reps], octave=oct, root='e')
arps = []
arp_count = 0
for arp_length in seg:
arp_length /= 2
arp_pair = arp_notes[ arp_count % len(arp_notes) ], arp_notes[ (arp_count + 1) % len(arp_notes) ]
stack = Waveset(rmx, limit=dsp.randint(5, 20), offset=dsp.randint(0, 100))
stack.normalize()
arp_one = oscs.Pulsar2d(stack, windows=['tri'], freq=arp_pair[0]*dsp.choice([1,2]), pulsewidth=dsp.win('rnd', 0.1, 1)).play(arp_length).env('hannout').taper(0.01) * dsp.rand(0.02, 0.2)
arp_two = oscs.Pulsar2d(stack, windows=['tri'], freq=arp_pair[1]*dsp.choice([1,2]), pulsewidth=dsp.win('rnd', 0.1, 1)).play(arp_length).env('hannout').taper(0.01) * dsp.rand(0.02, 0.2)
arp_one.dub(arp_two)
arps += [ arp_one ]
arp_count += 2
return dsp.join(arps).env('rnd').pan(dsp.rand())
def ping(maxlen=44100, freqs=None):
out = ''
if freqs is None:
freqs = [ dsp.rand(20,10000) for i in range(4) ]
tlen = dsp.randint(10, maxlen)
tones = [ dsp.tone(length=tlen, freq=freq, amp=0.1, wavetype='random')
for freq in freqs ]
tones = [ dsp.split(tone, 64) for tone in tones ]
pcurves = [ dsp.breakpoint([ dsp.rand() for t in range(len(tones[i]) / 20) ],
len(tones[i])) for i in range(len(tones)) ]
tones = [ [ dsp.pan(t, pcurves[i][ti]) for ti, t in enumerate(tones[i]) ]
for i in range(len(tones)) ]
fcurves = [ dsp.breakpoint([ dsp.rand(0.0, 0.1) + 0.9 for t in range(len(tones[i]) / 20) ],
len(tones[i])) for i in range(len(tones)) ]
tones = [ [ dsp.transpose(t, fcurves[i][ti] + 0.1) for ti, t in enumerate(tones[i]) ]
for i in range(len(tones)) ]
out = dsp.mix([ dsp.env(''.join(tone), 'random') for tone in tones ])
out = dsp.env(out, 'random')
out = dsp.pad(out, 0, dsp.randint(0, maxlen * 3))
return out
def makeSnare(length, i, amp):
s = dsp.cut(snare, 0, dsp.randint(dsp.mstf(40), dsp.flen(snare)))
s = dsp.alias(s, dsp.randint(4, 12))
s = dsp.taper(s)
s = dsp.fill(s, length, silence=True)
s = dsp.amp(s, dsp.rand(2,4))
return s
def play(ctl):
def stream(length, numsegments, freq):
out = []
seglength = dsp.randint(100, 300)
points = [ dsp.rand(-1, 1) for _ in range(dsp.randint(10, 20)) ]
for _ in range(numsegments):
seglength = dsp.cap(seglength + dsp.randint(-5, 5), 1000, 100)
points = [ dsp.cap(p + dsp.randint(-0.1, 0.1), 1, -1) for p in points ]
out += dsp.breakpoint([0] + points + [0], seglength)
print len(out), freq, length
out = dsp.ctone(freq, dsp.stf(length), out, dsp.rand(0.1, 0.5))
#out = dsp.env(out, 'random')
return out
numstreams = dsp.randint(20, 30)
out = ''
for _ in range(numstreams):
length = dsp.rand(100, 500) / 1000.0
numsegments = dsp.randint(100, 200)
freq = dsp.rand(200, 1000)
out += stream(length, numsegments, freq)
#out = dsp.env(out, 'random')
return out
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
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
def penv(snd, low=4, high=20):
packets = dsp.split(snd, dsp.dsp_grain)
ptable = dsp.breakpoint([ dsp.rand() for _ in range(dsp.randint(low, high)) ], len(packets))
etable = dsp.breakpoint([0] + [ dsp.rand() for _ in range(dsp.randint(low, high)) ] + [0], len(packets))
packets = [ dsp.pan(p, ptable[i], etable[i]) for i, p in enumerate(packets) ]
return ''.join(packets)
def makeLongChord(seg):
degrees = [dsp.randint(1, 9) for _ in range(dsp.randint(2, 4))]
long_chord = chord(sum(seg), [
freq * 2**dsp.randint(0, 5)
for freq in tune.fromdegrees(degrees, octave=1, root=key)
], dsp.rand(0.15, 0.35))
long_chord = dsp.fill(long_chord, sum(seg))
return long_chord
def singit(lyrics, mult):
words = text2wave(lyrics)
pitches = [ dsp.randint(1, 10) for i in range(dsp.randint(2, 4)) ]
pitches = tune.fromdegrees(pitches, octave=dsp.randint(1, 4), root='a')
sings = [ dsp.pine(words, dsp.flen(words) * mult, pitch) for pitch in pitches ]
sings = dsp.mix(sings)
sings = sox("sox %s %s tempo 5.0", sings)
return sings
def bass(amp, length, oct=2):
if amp == 0:
return dsp.buffer(length=length)
bass_note = dsp.choice(scale) * 0.25
stack = Waveset(rmx, limit=dsp.randint(5, 20), offset=dsp.randint(0, 100))
stack.normalize()
out = oscs.Pulsar2d(stack, windows=['sine'], freq=bass_note).play(length) * dsp.rand(0.02, 0.2)
out = fx.lpf(out, bass_note*2)
return out.env('hannout').taper(dsp.MS*10)
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 makeShape():
shape = []
num_shapelets = dsp.randint(3, 8)
for _ in range(num_shapelets):
shapelet_size = dsp.randint(20, 100)
num_points = dsp.randint(4, shapelet_size / dsp.randint(3, 4))
shapelet = dsp.breakpoint([ dsp.rand() for _ in range(num_points) ], shapelet_size)
shape += shapelet
return shape
def makeRhodes(length, beat, freqs, maxbend=0.05):
backup = Sampler(snds.load('tones/nycrhodes01.wav'), tune.ntf('c'), direction='fw-bw-loop', tails=False)
chord = [ keys.rhodes(length, freq, dsp.rand(0.4, 0.7)) for freq in freqs ]
chord = dsp.randshuffle(chord)
chord = [ dsp.mix([ dsp.env(fx.penv(backup.play(freq * 2**dsp.randint(0,2), length, dsp.rand(0.4, 0.6))), 'line'), c ]) for freq, c in zip(freqs, chord) ]
pause = 0
for i, c in enumerate(chord):
pause = pause + (dsp.randint(1, 4) * beat)
c = dsp.pan(c, dsp.rand())
c = fx.bend(c, [ dsp.rand() for _ in range(dsp.randint(5, 10)) ], dsp.rand(0, maxbend))
chord[i] = dsp.pad(dsp.fill(c, length - pause), pause, 0)
return dsp.mix(chord)
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 makeShape():
shape = []
num_shapelets = dsp.randint(3, 8)
for _ in range(num_shapelets):
shapelet_size = dsp.randint(20, 100)
num_points = dsp.randint(4, shapelet_size / dsp.randint(3, 4))
shapelet = dsp.breakpoint([dsp.rand() for _ in range(num_points)],
shapelet_size)
shape += shapelet
return shape
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 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):
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(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')
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 rhodes(total_time, freq=220.0, ampscale=0.5):
freq *= 2**dsp.randint(0, 2)
partials = [
# Multiple, amplitude, duration
[1, 0.6, 1.0],
[2, 0.25, 0.35],
[3, 0.08, 0.15],
[4, 0.005, 0.04],
]
layers = []
for plist in partials:
#env_length = (total_time * plist[2] * 2) / 32
partial = oscs.Osc('sine',
freq=plist[0] * freq,
amp=plist[1] *
ampscale).play(total_time).env('hannout')
#partial = dsp.split(partial, 32)
#partial = [ dsp.amp(partial[i], wtable[i]) for i in range(len(partial)) ]
#layer = ''.join(partial)
layers += [partial]
out = dsp.mix(layers)
n = noise.bln('sine', out.dur, 2000, 20000) * 0.005
out = dsp.mix([out, n])
return out
def makeArps(seg, oct=3, reps=4):
arp_degrees = [1,2,3,5,8,9,10]
if dsp.randint(0,1) == 0:
arp_degrees.reverse()
arp_degrees = dsp.rotate(arp_degrees, vary=True)
arp_notes = tune.fromdegrees(arp_degrees[:reps], oct, 'e')
arps = ''
arp_count = 0
for arp_length in seg:
arp_length /= 2
arp_pair = arp_notes[ arp_count % len(arp_notes) ], arp_notes[ (arp_count + 1) % len(arp_notes) ]
arp_one = dsp.tone(arp_length, wavetype='tri', freq=arp_pair[0], amp=0.075)
arp_one = dsp.env(arp_one, 'random')
arp_two = dsp.tone(arp_length, wavetype='tri', freq=arp_pair[1], amp=0.08)
arp_two = dsp.env(arp_two, 'random')
arps += arp_one + arp_two
arp_count += 2
arps = dsp.env(arps, 'random')
arps = dsp.pan(arps, dsp.rand())
return arps
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 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 spider(snd, numlayers=10, numgrains=20, minlen=40, lenranges=(300,500), reverse=False, env='hann'):
layers = []
for layer in range(numlayers):
lenrange = dsp.rand(lenranges[0], lenranges[1])
if reverse:
lengths = dsp.wavetable(env, numgrains * 2)[numgrains:]
else:
lengths = dsp.wavetable(env, numgrains * 2)[:numgrains]
lengths = [ dsp.mstf(l * lenrange + minlen) for l in lengths ]
pans = dsp.breakpoint([ dsp.rand() for p in range(numgrains / 3)], numgrains)
startpoint = dsp.randint(0, dsp.flen(snd) - max(lengths))
grains = ''
for l, p in zip(lengths, pans):
grain = dsp.cut(snd, startpoint, l)
grain = dsp.env(grain, 'phasor')
grain = dsp.taper(grain, dsp.mstf(10))
grain = dsp.pan(grain, p)
grains += grain
if reverse:
layers += [ dsp.env(grains, 'line') ]
else:
layers += [ dsp.env(grains, 'phasor') ]
return dsp.mix(layers)
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 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 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 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 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 play(self, freq, length, amp=1):
snd = dsp.transpose(self.snd, freq / self.freq)
snd = dsp.taper(snd, 40)
snd = dsp.amp(snd, amp)
if self.direction == 'fw':
snd = dsp.env(snd, self.env)
snd = dsp.fill(snd, length, silence=True)
if self.direction == 'fw-loop':
snd = dsp.fill(snd, length, silence=False)
snd = dsp.env(snd, self.env)
if self.direction == 'fw-loop-rand':
snd = dsp.env(snd, self.env)
elapsed = 0
sndout = ''
while elapsed < length:
sndout += dsp.pad(snd, 0, dsp.randint(0, dsp.flen(snd)))
elapsed = dsp.flen(sndout)
snd = dsp.fill(sndout, length, silence=False)
if self.direction == 'fw-bw-loop':
snd = dsp.fill(snd + dsp.reverse(snd), length, silence=False)
snd = dsp.env(snd, self.env)
if self.tails:
snd = dsp.mix([ snd, self.makeTails(freq, length) ])
return snd
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 chirp():
r = dsp.rand(3.6, 3.99)
numpoints = dsp.randint(10, 30)
freq = dsp.rand(200, 1000)
slength = dsp.rand(0.05, 0.5)
length = dsp.stf(slength)
log = data.Logistic(r, size=numpoints)
mod = dsp.breakpoint([0] + [dsp.rand()
for r in range(numpoints / 3)] + [0],
numpoints)
mod = [p * log.get() for p in mod]
modr = dsp.rand(1, 5)
modf = 1.0 / slength
wf = dsp.wavetable('sine2pi', 512)
win = dsp.wavetable('sine', 512)
pw = dsp.rand(0.5, 1)
amp = dsp.rand(0.1, 0.3)
out = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp)
out = dsp.env(out, 'random')
out = dsp.taper(out, dsp.mstf(10))
out = dsp.pan(out, dsp.rand())
out = dsp.pad(out, 0, dsp.stf(dsp.rand(0.1, 0.3)))
return out
def makeGlitch(length, i):
g = dsp.cut(long_chord, dsp.randint(0,
dsp.flen(long_chord) - length), length)
g = dsp.alias(g)
g = dsp.fill(g, length)
return g
def hihat(amp, length):
if amp == 0:
return dsp.pad('', 0, length)
def hat(length):
lowf = dsp.rand(600, 7000)
highf = dsp.rand(7000, 19000)
if dsp.randint(0, 6) == 0:
out = dsp.bln(length, lowf, highf)
out = dsp.env(out, 'line')
else:
out = dsp.bln(int(length * 0.05), lowf, highf)
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)
out = dsp.amp(out, amp)
return out
def make_layer(freq):
out = ''
for i in range(500):
out += make_vary(beat * dsp.randint(1, 8), freq)
return out
def blips(length, pos, total_length):
print('BLIPS', length, pos)
notes = [ rhodes.rhodes(dsp.rand(4, 7), freq, 0.3) for freq in scale ]
the_blip = notes[0].speed(2.0 * dsp.randint(1, 3)) * 0.4
blip = dsp.mix([ the_blip, notes[0].speed(1.5 * dsp.randint(1, 4)) * 0.4 ])
out = dsp.buffer(length=length)
for _ in range(dsp.randint(2, 6)):
ba = blip.cut(dsp.rand(0, blip.dur / 4), length / 2).pad(dsp.rand(0, length))
bb = blip.cut(dsp.rand(0, blip.dur / 4), length / 2).pad(dsp.rand(0, length))
b = dsp.mix([ba.pan(dsp.rand()), bb.pan(dsp.rand())]).taper(0.01)
b = fx.crush(b)
b = mixdrift(b)
out.dub(b)
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 makeScale():
scale = dsp.rotate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], vary=True)
if dsp.rand() > 0.5:
scale.reverse()
for _ in range(4, 8):
scale.pop(dsp.randint(0, len(scale) - 1))
return scale
def test_playall(self):
events = []
pos = 0
length = 10
while pos < length:
events += [
dict(start=pos,
length=dsp.rand(0.2, 3),
freq=30 * dsp.randint(1, 10),
amp=dsp.rand(),
voice=dsp.randint(0, 127))
]
pos += dsp.rand(0.01, 0.1)
out = soundfont.playall("tests/sounds/florestan-gm.sf2", events)
out = fx.norm(out, 0.5)
out.write('tests/renders/soundfont_playall.wav')
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 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 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 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 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 makeLayer(freq):
pw = dsp.rand()
wf = dsp.wavetable('tri', 512)
win = dsp.wavetable('hann', 512)
mod = dsp.breakpoint([ dsp.rand() for m in range(dsp.randint(4,8)) ], 512)
modf = dsp.rand(0.1, 2)
modr = dsp.rand(0, 0.01)
amp = dsp.rand(0.1, 0.5)
layer = dsp.pulsar(freq, length, pw, wf, win, mod, modf, modr, amp)
return layer
