def play(params):
length = params.get('length', dsp.stf(2))
reps = params.get('repeats', 4)
out = ''
stream = []
for rep in range(reps):
stream += [ ('/tick/6', 1, dsp.fts(length / 2)) ]
stream += [ ('/tick/6', 0, dsp.fts(length / 2)) ]
out += dsp.pad(dsp.amp(dsp.tone(length / 2), 0.1), 0, length/ 2)
return (out, {'value': {'events': [ stream ]}})
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 play(voice_id):
""" Every generator script must define a play() function, which
accepts a voice_id integer (so you can read and write params
for each voice) and returns a sound.
The shortname and name metadata above are optional, if you
don't include them the name will be drawn from the filename
and the shortname will be the first two characters of that name.
"""
# Get the current bpm set in our session
bpm = C('bpm')
# Convert it to a length in frames
beat = dsp.bpm2frames(bpm)
# Read per-instance param, with a default value
volume = P(voice_id, 'volume', default=1.0)
# Get a frequency for the beep
freq = tune.ntf('a', octave=2)
# Beep for a beat
out = dsp.tone(length=beat, freq=freq, wavetype='sine2pi', amp=volume)
# Be silent for a beat after the beep
out = dsp.pad(out, 0, beat)
# Log the length of the computed buffer.
# I like to tail -f pippi.log during performance.
dsp.log('voice %s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
# Pass along the final buffer for playback
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(voice_id):
tel = bot.getTel()
b = dsp.read('sounds/birds.wav').data
b = dsp.split(b, dsp.randint(100, 1000))
b = b[:dsp.randint(len(b) / 10, len(b))]
blen = len(b)
pans = dsp.breakpoint([ dsp.rand() for i in range(dsp.randint(10, 100)) ], blen)
speeds = dsp.breakpoint([ dsp.rand(0.25, 1.5) for i in range(dsp.randint(10, 100)) ], blen)
amps = dsp.breakpoint([ dsp.rand(0.05, 1.5) for i in range(dsp.randint(10, 100)) ], blen)
b = [ dsp.pan(b[i], pans[i]) for i in range(blen) ]
b = [ dsp.transpose(b[i], speeds[i]) for i in range(blen) ]
b = [ dsp.amp(b[i], amps[i]) for i in range(blen) ]
b = dsp.packet_shuffle(b, dsp.randint(4, 30))
for i, bb in enumerate(b):
if dsp.rand(0, 100) > 60:
b[i] = bb * dsp.randint(2, 10)
out = ''.join(b)
dsp.log('')
dsp.log('birds')
dsp.log(blen)
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def index():
tracks = []
data = g.db.execute('select * from `blocks`')
data = data.fetchall()
tracks = [ [] for i in range(10) ]
for i, row in enumerate(data):
tracks[row[3]].append((row[0], row[7], dsp.fts(row[4]), ftpx(row[4]), ftpx(row[6])))
return render_template('index.html', tracks=tracks, data=data)
def make_tracks(numtracks):
tracks = range(numtracks)
g.db.execute('delete from `blocks`;')
# Testing out display of rendered blocks
for i, track in enumerate(tracks):
blocks = range(dsp.randint(1, 5))
# for each sound:
for j, snd in enumerate(blocks):
# render it.
snd = dsp.tone(dsp.stf(dsp.rand(0.5, 5)))
# filename is track_id-block_id.wav for now
filename = "%i-%i-%i" % (i, j, 0)
# write it to disk
dsp.write(snd, 'static/sounds/%s' % filename)
# Calc length in pixels from frames
length = dsp.flen(snd)
pxlength = "%ipx" % (length / 441,)
slength = "%02fs" % dsp.fts(length)
offset = dsp.stf(dsp.rand(0, 60))
# save in the db
block = (
0,
0,
i,
length,
length,
offset,
filename,
)
g.db.execute('insert into `blocks` (version, generator_id, track_id, length, range, offset, filename) values (?, ?, ?, ?, ?, ?, ?)',
block)
c = g.db.cursor()
block_id = c.lastrowid()
# block is a tuple:
# (block index, filename, length in pixels, offset in pixels)
blocks[j] = (block_id, filename, slength, ftpx(length), ftpx(offset))
tracks[i] = blocks
g.db.commit()
return tracks
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 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 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 clap(length=22050, i=0, amp=0.5, root=3000.0, pw=None):
wav = dsp.breakpoint([0] + [ dsp.rand(-1,1) for w in range(50) ] + [0], 512)
win = dsp.wavetable('sine', 512)
mod = dsp.wavetable('phasor', 512)
klen = length / dsp.randint(2, 5)
if pw is None:
pw = dsp.rand(0.1, 1)
amp = dsp.rand(0.75, 1.0)
mFreq = 1.0 / dsp.fts(klen)
k = dsp.pulsar(root, klen, pw, wav, win, mod, 1.0, mFreq, amp)
#k = orc.kick(dsp.rand(0.4, 0.7), klen)
k = dsp.env(k, 'phasor')
k = dsp.pad(k, 0, length - klen)
return k
def play(voice_id):
bpm = C('bpm')
beat = dsp.bpm2frames(bpm)
volume = P(voice_id, 'volume', default=1.0)
chord = dsp.read('sounds/sag1.wav').data
bass = dsp.read('sounds/sag2.wav').data
out = ''
for i in range(32):
b = dsp.amp(bass, 0.5)
b = dsp.transpose(b, 2)
b *= 2
bar = dsp.flen(b) / 2
blayers = []
for blayer in range(3):
blayer = dsp.split(b, bar / dsp.randchoose([6, 12]))
blayer = dsp.randshuffle(blayer)
blayer = blayer[:2]
blayer = ''.join(blayer)
blayer = dsp.pan(blayer, dsp.rand())
# blayer *= dsp.randint(2, 8)
blayers += [ blayer ]
b = dsp.mix(blayers)
c = dsp.amp(chord, 0.5)
c = dsp.fill(c, bar / dsp.randchoose([8, 16, 12, 24]))
c = dsp.fill(c, dsp.flen(b))
out += dsp.mix([ b, c ])
dsp.log('voice %s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
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 kick(length=22050, i=0, amp=0.5):
wav = dsp.breakpoint([0] + [ dsp.rand(-1,1) for w in range(20) ] + [0], 512)
win = dsp.wavetable('sine', 512)
mod = dsp.wavetable('phasor', 512)
root = 30.0
klen = length / 4
pw = dsp.rand(0.1, 1)
amp = dsp.rand(0.5, 1.0)
mFreq = 1.0 / dsp.fts(klen)
k = dsp.pulsar(root, klen, pw, wav, win, mod, 2.0, mFreq, amp)
k = dsp.mix([ sinekick(amp=dsp.rand(0.4, 0.7), length=klen), k ])
k = dsp.env(k, 'phasor')
k = dsp.pad(k, 0, length - klen)
return k
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 rb(snd, length=None, speed=None, hz=None, interval=None, ratios=None, crisp=0, formant=False):
pid = os.getpid()
cmd = ['rubberband']
# Time stretching
if length is not None and dsp.flen(snd) != length and length > 0:
cmd += [ '--duration %s' % dsp.fts(length) ]
# crisp setting
cmd += [ '--crisp %s' % dsp.cap(crisp, 6, 0) ]
# preserve formants
if formant:
cmd += [ '--formant' ]
# pitch shift by speed
if speed is not None:
cmd += [ '--frequency %s' % speed ]
# pitch shift by semitones
if interval is not None:
# TODO use pippi.tune ratios and calc frequency args
cmd += [ '--pitch %s' % interval ]
vpid = pid + random.randint(1, 10000)
cmd = ' '.join(cmd) + ' /tmp/infile%s.wav /tmp/outfile%s.wav' % (vpid, vpid)
dsp.write(snd, '/tmp/infile%s' % vpid, cwd=False)
with open(os.devnull, 'w') as devnull:
p = subprocess.Popen(cmd, stdout=devnull, stderr=devnull, shell=True)
p.wait()
out = dsp.read('/tmp/outfile%s.wav' % vpid).data
os.remove('/tmp/outfile%s.wav' % vpid)
os.remove('/tmp/infile%s.wav' % vpid)
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 yourlove(length=22050, i=0, bar=5, amp=0.5, chords=None, root='a', octave=3, maxdiv=4, mindiv=1):
""" Inspired by Terre """
wav = dsp.wavetable('sine2pi', 512)
win = dsp.wavetable('sine', 512)
mod = dsp.wavetable('phasor', 512)
if chords is None:
chords = [
[5, 7, 1],
[5, 4, 1],
[3, 2, 1, 6],
]
pw = dsp.rand(0.1, 1)
notes = chords[i % len(chords)]
notes = tune.fromdegrees(notes, root=root, octave=octave)
klen = length / dsp.randint(mindiv, maxdiv)
amp = dsp.rand(0.3, 0.5)
mFreq = dsp.rand(0.5, 1.0) / dsp.fts(klen)
layers = []
for note in notes:
k = dsp.pulsar(note, klen, pw, wav, win, mod, 0.005, mFreq, amp)
k = dsp.env(k, 'sine')
k = dsp.pan(k, dsp.rand())
k = dsp.pad(k, 0, length - klen)
layers += [ k ]
out = dsp.mix(layers)
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)
grains = dsp.amp(grains, dsp.rand(0.25, 0.55))
grains = mixdrift(grains)
layers += [grains]
sounds = dsp.fill(dsp.mix(layers), tlen)
if canPlay('ending', bigoldsection):
sounds = dsp.vsplit(sounds, dsp.mstf(1), dsp.mstf(200))
sounds = [
dsp.pad(s, 0, dsp.mstf(dsp.rand(50, 250))) for s in sounds
]
sounds = ''.join(sounds)
subsection_length = dsp.flen(sounds)
print 'subsection length:', dsp.fts(subsection_length), seg_index
section += sounds
section_length = dsp.flen(section)
print 'section length:', dsp.fts(section_length)
sections += [section]
print
print
out = ''.join(sections)
dsp.write(out, 'amber', timestamp=True)
grains = dsp.mix(grains)
grains = dsp.amp(grains, dsp.rand(0.25, 0.55))
grains = mixdrift(grains)
layers += [ grains ]
sounds = dsp.fill(dsp.mix(layers), tlen)
if canPlay('ending', bigoldsection):
sounds = dsp.vsplit(sounds, dsp.mstf(1), dsp.mstf(200))
sounds = [ dsp.pad(s, 0, dsp.mstf(dsp.rand(50, 250))) for s in sounds ]
sounds = ''.join(sounds)
subsection_length = dsp.flen(sounds)
print 'subsection length:', dsp.fts(subsection_length), seg_index
section += sounds
section_length = dsp.flen(section)
print 'section length:', dsp.fts(section_length)
sections += [ section ]
print
print
out = ''.join(sections)
dsp.write(out, 'amber', timestamp=True)
