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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 make_pulses(degrees, bpm):
freqs = tune.fromdegrees(degrees, 3, 'c')
layers = []
for freq in freqs:
l = dsp.pine(dsp.amp(thirty, 0.5), int(dsp.flen(thirty) * 20), freq)
l = dsp.pan(l, dsp.rand())
layers += [ l ]
t = dsp.mix(layers)
t = dsp.split(t, dsp.mstf(dsp.bpm2ms(bpm)))
t = dsp.randshuffle(t)
return ''.join(t)
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 make(length, i):
r = dsp.transpose(guitar, getRatio(scale[ i % len(scale)]))
r = dsp.mix([ dsp.pan(r, dsp.rand()), dsp.drift(dsp.pan(r, dsp.rand()), dsp.rand(0.001, 0.02)) ])
if dsp.rand() > 0.5:
r = dsp.alias(r)
if dsp.rand() > 0.5:
r = dsp.split(r, dsp.flen(r) / dsp.randint(2,5))
r = dsp.randshuffle(r)
r = ''.join(r)
r = dsp.amp(r, dsp.rand(0.1, 0.75))
g = dsp.fill(r, length, silence=True)
return g
def makeArps(length, beat, cname):
freqs = tune.chord(cname, key, dsp.randint(1,4))
tone = Sampler(snds.load('tones/nick.wav'), direction='fw-bw-loop', tails=False)
freqs = dsp.randshuffle(freqs)
beat = int((beat * 2) / dsp.randchoose([0.5, 1, 2, 3, 1.5]))
numbeats = length / beat
out = ''
for i in range(numbeats):
out += tone.play(freqs[i % len(freqs)], beat)
out = dsp.fill(out, length)
out = fx.penv(out)
return out
def make(length, i):
r = dsp.transpose(guitar, getRatio(scale[i % len(scale)]))
r = dsp.mix([
dsp.pan(r, dsp.rand()),
dsp.drift(dsp.pan(r, dsp.rand()), dsp.rand(0.001, 0.02))
])
if dsp.rand() > 0.5:
r = dsp.alias(r)
if dsp.rand() > 0.5:
r = dsp.split(r, dsp.flen(r) / dsp.randint(2, 5))
r = dsp.randshuffle(r)
r = ''.join(r)
r = dsp.amp(r, dsp.rand(0.1, 0.75))
g = dsp.fill(r, length, silence=True)
return g
def play(params):
length = params.get('length', dsp.stf(dsp.rand(0.1, 1)))
volume = params.get('volume', 100.0) / 100.0
speed = params.get('speed', dsp.rand(0.3, 0.5))
octave = params.get('octave', 2)
note = params.get('note', ['c'])[0]
env = params.get('envelope', False)
pad = params.get('padding', False)
bend = params.get('bend', False)
wform = params.get('waveform', False)
instrument = params.get('instrument', 'r')
scale = params.get('scale', [1,6,5,4,8])
shuffle = params.get('shuffle', False) # Reorganize input scale
reps = params.get('repeats', len(scale))
alias = params.get('alias', False)
lyrics = params.get('ww', '1-2-3-4-5-6-7-8-9-10').split('-')
bpm = params.get('bpm', 100)
if shuffle:
lyrics = dsp.randshuffle(lyrics)
lyrics = ' '.join(lyrics)
words = text2wave(lyrics)
words = sox("sox %s %s silence 1 0.1 1%% -1 0.1 1%%", words)
words = dsp.transpose(words, speed)
pitches = tune.fromdegrees(scale, octave=octave, root=note)
length = dsp.flen(words) * dsp.randint(30, 32)
sings = [ dsp.pine(words, length, pitch) for pitch in pitches ]
sings = dsp.mix(sings)
sings = sox("sox %s %s tempo 6.0", sings)
out = dsp.pan(sings, dsp.rand())
return out
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 = 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(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):
pianos = ['sawvib', 'piano', 'pianooct1', 'harp', 'saw']
pianos = ['sawvib', 'piano']
piano = snds.load('genie/%s.wav' % dsp.randchoose(pianos))
notes = [1,3,5]
chord = tune.fromdegrees([ dsp.randchoose(notes) + (dsp.randchoose([0, 1]) * 8) for _ in range(dsp.randint(1, 3)) ], octave=0)
length = dsp.stf(dsp.rand(1, 4))
layers = []
for freq in chord:
p = dsp.transpose(piano, freq / 220.0)
p = dsp.amp(p, 0.35)
#p = dsp.pan(p, dsp.rand())
p = dsp.fill(p, length)
if dsp.rand() > 0.25:
p = dsp.vsplit(p, dsp.mstf(100), dsp.mstf(500))
p = [ dsp.pan(pp, dsp.rand()) for pp in p ]
p = [ dsp.amp(pp, dsp.rand(0,2)) for pp in p ]
p = [ dsp.transpose(pp, dsp.randchoose([1,2,4,8])) for pp in p ]
p = [ dsp.taper(pp, 20) for pp in p ]
p = [ dsp.pad(pp, 0, dsp.mstf(dsp.rand(0, 100))) for pp in p ]
p = dsp.randshuffle(p)
p = ''.join(p)
if dsp.rand() > 0.75:
p = dsp.alias(p)
#p = dsp.env(p, 'phasor')
layers += [ p ]
out = dsp.mix(layers)
return out
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(voice_id):
bpm = config('bpm')
beat = dsp.bpm2frames(bpm)
dsl = P(voice_id, 'drum', 'h.c')
length = int(P(voice_id, 'length', dsp.stf(dsp.rand(5, 12))))
volume = P(voice_id, 'volume', 70.0)
volume = volume / 100.0 # TODO move into param filter
octave = P(voice_id, 'octave', 3)
notes = P(voice_id, 'note', '["%s"]' % config('key'))
notes = json.loads(notes)
hertz = P(voice_id, 'hertz', False)
alias = P(voice_id, 'alias', False)
alias = True
bend = P(voice_id, 'bend', False)
env = P(voice_id, 'envelope', 'gauss')
harmonics = P(voice_id, 'harmonic', '[1,2,3,4]')
harmonics = json.loads(harmonics)
reps = P(voice_id, 'repeats', 1)
waveform = P(voice_id, 'waveform', 'sine2pi')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
glitch = False
#glitch = True
root = 27.5
pinecone = False
bbend = False
wild = False
if bbend == True:
bend = True
tune.a0 = float(root)
# These are amplitude envelopes for each partial,
# randomly selected for each. Not to be confused with
# the master 'env' param which is the amplit
wtypes = ['sine', 'phasor', 'line', 'saw']
layers = []
if hertz is not False:
notes = hertz
for note in notes:
tones = []
for i in range(dsp.randint(2,4)):
if hertz is not False:
freq = float(note)
if octave > 1:
freq *= octave
else:
freq = tune.ntf(note, octave)
snds = [ dsp.tone(length, freq * h, waveform, 0.05) for h in harmonics ]
snds = [ dsp.env(s, dsp.randchoose(wtypes), highval=dsp.rand(0.3, 0.6)) for s in snds ]
snds = [ dsp.pan(s, dsp.rand()) for s in snds ]
if bend is not False:
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)
snds = [ bendit(snd) for snd in snds ]
tones += [ dsp.mix(snds) ]
layer = dsp.mix(tones)
if wild != False:
layer = dsp.vsplit(layer, 41, 4410)
layer = [ dsp.amp(dsp.amp(l, dsp.rand(10, 20)), 0.5) for l in layer ]
layer = ''.join(layer)
if pinecone != False:
layer = dsp.pine(layer, length, freq, 4)
if glitch == True:
layer = dsp.vsplit(layer, dsp.mstf(10), dsp.flen(layer) / 4)
layer = dsp.randshuffle(layer)
layer = ''.join(layer)
layer = dsp.env(layer, env)
layers += [ layer ]
out = dsp.mix(layers) * reps
return dsp.amp(out, volume)
def play(ctl):
param = ctl.get('param')
lpd = ctl.get('midi').get('lpd')
scale = [ dsp.randchoose([1, 5, 8]) for s in range(dsp.randint(2, 4)) ]
freqs = tune.fromdegrees(scale, root='eb', octave=dsp.randint(0, 2))
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.005)
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.5, 0.8)
length = dsp.stf(lpd.get(5, low=0.5, high=14, default=1) * dsp.rand(0.75, 2))
length = dsp.stf(dsp.rand(1, 3) * dsp.rand(0.75, 2))
wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for w in range(5) ] + [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]
for harmonic in harmonics:
f = freq * harmonic
if harmonic > 4:
a = dsp.rand(0.5, 1)
else:
a = amp * dsp.rand(0.5, 1)
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 ])
layer = dsp.vsplit(layer, dsp.mstf(5), dsp.mstf(1500))
layer = dsp.randshuffle(layer)
layer = ''.join(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.taper(out)
#out = dsp.env(out, 'random')
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)
amp = dsp.rand(0.1, 0.65)
nlens = [
beat * 4,
beat * 3,
beat * 2,
beat + (beat / 2),
beat,
beat / 2,
beat / 4,
]
scale = [2, 4, 6, 9]
scale = [1, 4, 6, 8]
# scale = [1,3,4,5,6,8,9]
# scale = [1,2,3,5,6,8,9]
# scale = [1,5,8]
freqs = tune.fromdegrees(scale,
root=root,
octave=dsp.randint(2, 4),
ratios=ratios,
scale=quality)
# length of pattern (in beats)
elen = 0
tlen = beat * dsp.randint(2, 8)
# beat lengths (from a set of bpm-derived note lengths defined in the nlens list)
blens = []
while elen < tlen:
l = dsp.randchoose(nlens)
blens += [l]
elen += l
# beat pulsewidths
bpws = [dsp.rand(0.1, 1) for pw in range(len(blens))]
out = ''
# choose a pitch from the scale
freq = dsp.randchoose(freqs)
# synthesize the tones
for i in range(len(blens)):
# find the length of the pulse
blen = int(round(blens[i] * bpws[i]))
# find the length of the rest
brest = blens[i] - blen
# make a rhodes tone with a random amplitude
#beat = keys.rhodes(length=blen, freq=freq, amp=dsp.rand(0.3, 0.5))
beat = keys.rhodes(length=blen, freq=freq, amp=amp)
# pan the tone to a random position
beat = dsp.pan(beat, dsp.rand())
# bitcrush the tone a random amount
# beat = dsp.alias(beat)
# pad the tone with silence
beat = dsp.pad(beat, 0, brest)
# add it to the output
out += beat
out *= dsp.randint(1, 2)
if dsp.rand() > 0.75:
out = dsp.split(out, dsp.bpm2frames(bpm) / dsp.randchoose([1, 2, 4]))
out = dsp.randshuffle(out)
out = ''.join(out)
return out
def play(ctl):
mpk = ctl.get('midi').get('mpk')
ssnd = dsp.read('/home/hecanjog/sounds/drums/78sd.wav').data
lssnd = dsp.read('jesssnare.wav').data
hsnd = dsp.read('/home/hecanjog/sounds/drums/78ch.wav').data
ohsnd = dsp.read('/home/hecanjog/sounds/drums/78oh.wav').data
ksnd = dsp.read('jesskick.wav').data
beat = dsp.bpm2frames(166)
length = beat * 8
if dsp.rand() > 0.5:
kick = 'x--x-x-x--------'
else:
kick = 'x----x----------'
hat = 'x-x-x-x-xx-x-x-x'
ohat = 'x------x--------'
lsnare = '---------x--x---'
if dsp.rand() > 0.5:
lsnare = '---------x--x---'
else:
lsnare = '--x--x--x--x--x-'
snare = '--x--x--x--x--x-'
def makeOHat(length, i, amp):
return dsp.fill(hsnd, length, silence=True)
def makeHat(length, i, amp):
return dsp.fill(ohsnd, length, silence=True)
def makeKick(length, i, amp):
k = dsp.fill(ksnd, length, silence=True)
return dsp.amp(k, 3)
def makeSnare(length, i, amp):
s = dsp.fill(ssnd, length, silence=True)
return dsp.amp(s, 2)
def makeLSnare(length, i, amp):
s = dsp.fill(lssnd, length, silence=True)
return dsp.amp(s, 1)
hats = drums.parsebeat(hat, 8, beat, length, makeHat, 5)
ohats = drums.parsebeat(ohat, 8, beat, length, makeOHat, 0)
kicks = drums.parsebeat(kick, 8, beat, length, makeKick, 0)
snares = drums.parsebeat(snare, 8, beat, length, makeSnare, 0)
lsnares = drums.parsebeat(lsnare, 8, beat, length, makeLSnare, 0)
snaresnstuff = dsp.mix([ohats,snares])
snaresnstuff= dsp.split(snaresnstuff, dsp.flen(snaresnstuff) / 32)
snaresnstuff = dsp.randshuffle(snaresnstuff)
snaresnstuff = ''.join(snaresnstuff)
snaresnstuff = dsp.amp(snaresnstuff, 0.35)
out = dsp.mix([kicks,lsnares,snares,hats,ohats,snaresnstuff])
return out
numbeats = 16 * dsp.randint(2, 20)
if section == 'ending':
numbeats = dsp.randint(16, 40)
bpm = 84
beat = dsp.bpm2frames(bpm) / 4
bar_length = beat * numbeats
bar = dsp.pad('', 0, bar_length)
if canPlay('choppy', section):
dl = ''.join([ dsp.mix([ dsp.randchoose([ dloop1, dloop2 ]), dsp.randchoose([ kickhard, kicksoft ]) ]) for _ in range(3) ])
dl = dsp.split(dl, dsp.flen(dl) / 16)
dl = dsp.randshuffle(dl)
dl = [ dsp.env(dd, 'phasor') for dd in dl ]
for i, b in enumerate(dl):
if dsp.rand() > 0.75:
dl[i] = dsp.pad('', 0, dsp.flen(b))
elif dsp.rand() > 0.75:
dl[i] = dsp.split(b, dsp.flen(b) / 2)[0] * 2
dl[i] = dsp.amp(dl[i], dsp.rand(0.9, 2))
dl[i] = dsp.fill(dl[i], beat, silence=True)
dl = ''.join(dl)
layers += [ dl ]
if canPlay('swells', section):
octave = 1 if section == 'float' else dsp.randint(2, 3)
from pippi import dsp
main = dsp.read('base_loop.wav').data
synth = dsp.read('synthloop.wav').data
beat = dsp.flen(main) / 128
freq = 430
s = dsp.pine(synth, dsp.flen(main) * 8, freq)
s = dsp.split(s, beat)
s = dsp.randshuffle(s)
s = [dsp.alias(ss) for ss in s]
s = [dsp.amp(ss, dsp.rand(0.5, 2)) 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.split(synth, beat)
s2 = dsp.randshuffle(s2)
s2 = [dsp.transpose(ss, dsp.randchoose([1, 2, 4])) for ss in s2]
s2 = [dsp.fill(ss, beat) for ss in s2]
s2 = [dsp.env(ss, 'phasor') for ss in s2]
s2 = ''.join(s2)
synth = dsp.mix([s, s2])
synth = dsp.fill(synth, dsp.flen(main))
#synth = dsp.fill(synth, dsp.flen(main))
out = dsp.mix([main, synth])
#out = synth
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)
def play(params):
""" Usage:
shine.py [length] [volume]
"""
length = params.get('length', dsp.stf(dsp.rand(0.1, 1)))
volume = params.get('volume', 100.0)
volume = volume / 100.0 # TODO: move into param filter
octave = params.get('octave', 2) + 1 # Add one to compensate for an old error for now
note = params.get('note', ['c'])
note = note[0]
quality = params.get('quality', tune.major)
glitch = params.get('glitch', False)
superglitch = params.get('superglitch', False)
pinecone = params.get('pinecone', False)
glitchpad = params.get('glitch-padding', 0)
glitchenv = params.get('glitch-envelope', False)
env = params.get('envelope', False)
ratios = params.get('ratios', tune.terry)
pad = params.get('padding', False)
bend = params.get('bend', False)
bpm = params.get('bpm', 75.0)
width = params.get('width', False)
wform = params.get('waveform', False)
instrument = params.get('instrument', 'r')
scale = params.get('scale', [1,6,5,4,8])
shuffle = params.get('shuffle', False) # Reorganize input scale
reps = params.get('repeats', len(scale))
alias = params.get('alias', False)
phase = params.get('phase', False)
pi = params.get('pi', False)
wild = params.get('wii', False)
root = params.get('root', 27.5)
trigger_id = params.get('trigger_id', 0)
tune.a0 = float(root)
try:
# Available input samples
if instrument == 'r':
instrument = 'rhodes'
tone = dsp.read('sounds/synthrhodes.wav').data
elif instrument == 's':
instrument = 'synthrhodes'
tone = dsp.read('sounds/220rhodes.wav').data
elif instrument == 'c':
instrument = 'clarinet'
tone = dsp.read('sounds/clarinet.wav').data
elif instrument == 'v':
instrument = 'vibes'
tone = dsp.read('sounds/glock220.wav').data
elif instrument == 't':
instrument = 'tape triangle'
tone = dsp.read('sounds/tape220.wav').data
elif instrument == 'g':
instrument = 'glade'
tone = dsp.read('sounds/glade.wav').data
elif instrument == 'p':
instrument = 'paperclips'
tone = dsp.read('sounds/paperclips.wav').data
elif instrument == 'i':
instrument = 'input'
tone = dsp.capture(dsp.stf(1))
except:
instrument = None
tone = None
out = ''
# Shuffle the order of pitches
if shuffle is not False:
scale = dsp.randshuffle(scale)
# Translate the list of scale degrees into a list of frequencies
freqs = tune.fromdegrees(scale, octave, note, quality, ratios)
freqs = [ freq / 4.0 for freq in freqs ]
# Format is: [ [ path, offset, id, value ] ]
# Offset for video
osc_messages = [ ['/dac', float(dsp.fts(length)), 1, tune.fts(osc_freq)] for osc_freq in freqs ]
# Phase randomly chooses note lengths from a
# set of ratios derived from the current bpm
if phase is not False:
ldivs = [0.5, 0.75, 2, 3, 4]
ldiv = dsp.randchoose(ldivs)
length = dsp.bpm2ms(bpm) / ldiv
length = dsp.mstf(length)
reps = ldiv if ldiv > 1 else 4
# Construct a sequence of notes
for i in range(reps):
# Get the freqency
freq = freqs[i % len(freqs)]
# Transpose the input sample or
# synthesize tone
if wform is False and tone is not None:
# Determine the pitch shift required
# to arrive at target frequency based on
# the pitch of the original samples.
if instrument == 'clarinet':
diff = freq / 293.7
elif instrument == 'vibes':
diff = freq / 740.0
else:
diff = freq / 440.0
clang = dsp.transpose(tone, diff)
elif wform == 'super':
clang = dsp.tone(length, freq, 'phasor', 0.5)
clang = [ dsp.drift(clang, dsp.rand(0, 0.02)) for s in range(7) ]
clang = dsp.mix(clang)
elif wform is False and tone is None:
clang = dsp.tone(length, freq, 'sine2pi', 0.75)
clang = dsp.amp(clang, 0.6)
else:
clang = dsp.tone(length, freq, wform, 0.75)
clang = dsp.amp(clang, 0.6)
# Stupidly copy the note enough or
# trim it to meet the target length
clang = dsp.fill(clang, length)
# Give synth tones simple env (can override)
if wform is not False and env is False:
clang = dsp.env(clang, 'phasor')
# Apply an optional amplitude envelope
if env is not False:
clang = dsp.env(clang, env)
# Add optional padding between notes
if pad != False:
clang = dsp.pad(clang, 0, pad)
# Add to the final note sequence
out += clang
# Add optional aliasing (crude bitcrushing)
if alias is not False:
out = dsp.alias(out)
# Cut sound into chunks of variable length (between 5 & 300 ms)
# Pan each chunk to a random position
# Apply a sine amplitude envelope to each chunk
# Finally, add variable silence between each chunk and shuffle the
# order of the chunks before joining.
if glitch is not False:
out = dsp.vsplit(out, dsp.mstf(5), dsp.mstf(300))
out = [dsp.pan(o, dsp.rand()) for o in out]
out = [dsp.env(o, 'sine') for o in out]
out = [dsp.pad(o, 0, dsp.mstf(dsp.rand(0, glitchpad))) for o in out]
out = ''.join(dsp.randshuffle(out))
# Detune between 1.01 and 0.99 times original speed
# as a sine curve whose length equals the total output length
if bend is not False:
out = dsp.split(out, 441)
freqs = dsp.wavetable('sine', len(out), 1.01, 0.99)
out = [ dsp.transpose(out[i], freqs[i]) for i in range(len(out)) ]
out = ''.join(out)
if wild is not False:
#out = dsp.vsplit(out, 400, 10000)
out = dsp.split(out, 3000)
out = [ dsp.amp(dsp.amp(o, dsp.rand(10, 50)), 0.5) for o in out ]
#out = [ o * dsp.randint(1, 5) for o in out ]
for index, o in enumerate(out):
if dsp.randint(0, 1) == 0:
out[index] = dsp.env(dsp.cut(o, 0, dsp.flen(o) / 4), 'gauss') * 4
if dsp.randint(0, 6) == 0:
out[index] = dsp.transpose(o, 8)
out = [ dsp.env(o, 'gauss') for o in out ]
freqs = dsp.wavetable('sine', len(out), 1.02, 0.98)
out = [ dsp.transpose(out[i], freqs[i]) for i in range(len(out)) ]
out = ''.join(out)
if pinecone == True:
out = dsp.pine(out, int(length * dsp.rand(0.5, 8.0)), dsp.randchoose(freqs) * dsp.rand(0.5, 4.0))
# Adjust output amplitude as needed and return audio + OSC
if pi:
return (dsp.amp(out, volume), {'osc': osc_messages})
else:
return dsp.amp(out, volume)
def play(ctl):
mpk = ctl.get('midi').get('mpk')
ccs = [ i + 48 for i in range(24) ]
notes = []
for cc in ccs:
if mpk.get(cc) < 1:
notes += [ cc ]
ssnd = dsp.read('/home/hecanjog/sounds/drums/78sd.wav').data
ssnd = dsp.read('jesssnare.wav').data
hsnd = dsp.read('/home/hecanjog/sounds/drums/Shaker.wav').data
ksnd = dsp.read('/home/hecanjog/sounds/drums/Drybd2.wav').data
#ksnd = dsp.read('jesskick.wav').data
beat = dsp.bpm2frames(90)
#beat = dsp.mstf(290 * 2)
length = beat * 4
hat = 'xxx '
kick = 'x '
snare = ' x '
#snare = ' x xx'
#snare = ' '
def makeHat(length, i, amp):
h = hsnd
h = dsp.env(h, 'phasor')
h = dsp.pad(h, 0, length - dsp.flen(h))
return h
def makeKick(length, i, amp):
k = dsp.mix([ ksnd, drums.sinekick(length, i, amp) ])
#k = dsp.env(ksnd, 'phasor')
k = dsp.fill(k, length, silence=True)
k = dsp.amp(k, 1)
return k
def makeSnare(length, i, amp):
s = ssnd
s = dsp.amp(s, 1.2)
s = dsp.transpose(s, dsp.rand(1.5, 3))
s = dsp.fill(s, length, silence=True)
#ss = dsp.drift(s, dsp.rand(0.001, 0.1))
#s = dsp.mix([s, ss])
return s
#hats = drums.parsebeat(hat, 16, beat, length, makeHat, 25)
hats = drums.parsebeat(hat, 16, beat, length, makeHat, 0)
kicks = drums.parsebeat(kick, 16, beat, length, makeKick, 0)
snares = drums.parsebeat(snare, 8, beat, length, makeSnare, 0)
out = dsp.mix([hats,kicks,snares])
shuf = True
shuf = False
if shuf:
out = dsp.split(out, beat)
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.amp(out, 2)
cuts = True if dsp.rand() > 0.5 else False
cuts = True
#cuts = False
if cuts:
o = dsp.split(out, beat / 2)
o = dsp.randshuffle(o)
o = [ dsp.amp(oo, dsp.rand(0, 2.5)) for oo in o ]
o = [ dsp.env(oo, 'random') for oo in o ]
out = dsp.mix([ ''.join(o), out ])
dsp.log(notes)
synthy = False
#synthy = True
if synthy == True:
s = ''
for ii in range(dsp.flen(out) / (beat/2)):
layers = []
if len(notes) > 0:
scale = [ n - 47 for n in notes ]
scale = [1,5,8,12]
scale = tune.fromdegrees(scale, octave=3, root='d')
p = ''.join([ keys.pulsar(scale[ii % len(scale)], pulsewidth=dsp.rand(0.1, 1), amp=0.5, length=(beat/2) / 3) for _ in range(3) ])
layers += [ p ]
else:
layers += [ dsp.pad('', beat / 2, 0) ]
s += dsp.mix(layers)
out = dsp.mix([ s, out ])
#out = dsp.alias(out)
#out = dsp.drift(out, dsp.rand(0.5, 2))
return out
def play(params):
length = params.get("length", dsp.mstf(10000))
buffer_index = params.get("buffer_index", False)
sample_index = params.get("sample_index", False)
buffer_length = params.get("buffer_length", dsp.stf(5))
volume = params.get("volume", 100.0) / 100.0
scale = params.get("scale", [25, 50, 100, 200])
octave = params.get("octave", 0)
envelope = params.get("envelope", False)
glitch = params.get("glitch", True)
overdub = params.get("dub", False)
pad = params.get("padding", False)
pan = params.get("pan", False)
if sample_index != False:
out = dsp.read("samps/pre/buf-%s.wav" % str(sample_index)).data
elif buffer_index != False:
fname = "samps/buf-%s" % str(buffer_index)
if not os.path.exists(fname + ".wav") or overdub == True:
out = rt.capture(buffer_length, "T6_pair1", 1)
out = sox("sox %s %s silence 1 0.1 1%% -1 0.1 1%%", out)
out = dsp.transpose(out, 0.5)
else:
out = dsp.read("samps/buf-%s.wav" % str(buffer_index)).data
else:
out = rt.capture(buffer_length, "T6_pair1", 1)
out = sox("sox %s %s silence 1 0.1 1%% -1 0.1 1%%", out)
out = dsp.transpose(out, 0.5)
speeds = [s / 100.0 for s in scale]
# speeds = [ 0.25, 0.5, 1.0, 2.0 ]
if glitch == True:
grain_length = dsp.flen(out) / 4
out = dsp.vsplit(out, int(grain_length * 0.5), grain_length)
numgrains = (length / grain_length) * 2
if len(out) < numgrains:
for i in range(numgrains - len(out)):
out += [dsp.randchoose(out)]
layers = []
for index in range(1, 20):
layer = dsp.randshuffle(out)
if pad is not False:
layer = [dsp.pad(grain, 0, pad) for grain in layer]
layer = [dsp.env(grain, "sine") for grain in layer]
layer = [dsp.transpose(grain, dsp.randchoose(speeds) * 2 ** octave * 0.25) for grain in layer]
layer = "".join(layer)
layer = dsp.pad(layer, grain_length / index, 0)
layers += [layer]
out = dsp.mix(layers, True, 10)
if envelope == True:
out = dsp.env(out, envelope)
if buffer_index:
fname = "samps/buf-%s" % str(buffer_index)
if os.path.exists(fname + ".wav") and overdub == False:
pass
else:
dsp.write(out, fname)
if pan:
out = dsp.pan(out, dsp.rand())
return out
s = dsp.fill(ssnd, length, silence=True)
return dsp.amp(s, 3)
def makeLSnare(length, i, amp):
s = dsp.fill(lssnd, length, silence=True)
return dsp.amp(s, 2)
hats = drums.parsebeat(hat, 8, beat, length, makeHat, 5)
ohats = drums.parsebeat(ohat, 8, beat, length, makeOHat, 0)
kicks = drums.parsebeat(kick, 8, beat, length, makeKick, 0)
snares = drums.parsebeat(snare, 8, beat, length, makeSnare, 0)
lsnares = drums.parsebeat(lsnare, 8, beat, length, makeLSnare, 0)
snaresnstuff = dsp.mix([ohats,snares])
snaresnstuff= dsp.split(snaresnstuff, dsp.flen(snaresnstuff) / 32)
snaresnstuff = dsp.randshuffle(snaresnstuff)
snaresnstuff = [ dsp.env(sns, 'phasor') for sns in snaresnstuff ]
snaresnstuff = ''.join(snaresnstuff)
snaresnstuff = dsp.amp(snaresnstuff, 0.5)
bar = dsp.mix([kicks,lsnares,snares,hats,ohats,snaresnstuff])
#bar = dsp.mix([hats,ohats])
if count % 4 == 0:
bar = dsp.mix([ bar, dsp.fill(bksnd, dsp.flen(bar), silence=True) ])
progression = 'ii6 ii69'.split(' ')
cname = progression[ count % len(progression) ]
rfreqs = tune.chord(cname, key, 2)
rhodes = makeRhodes(dsp.flen(bar), beat / 8, rfreqs)
def play(voice_id):
tel = bot.getTel()
if 'sparse' in tel['name'] or 'ballsout' in tel['name'] and dsp.rand(0, 100) > 70:
dsp.log('')
dsp.log(voice_id + ' pulsar silent')
bot.show_telemetry(tel)
#return dsp.pad('', 0, dsp.stf(dsp.rand(1, 10)))
#####################
# PARAMS
#####################
volume = dsp.rand(0.4, 0.7)
melodies = [[dsp.randchoose([1, 5, 6])]]
if tel['density'] >= 4:
melodies += [ [ dsp.randchoose([1, 2, 9, 5, 6]) for i in range(2) ] for m in range(dsp.randint(2, 4)) ]
if tel['density'] >= 6:
melodies += [ [ dsp.randchoose([1, 2, 9, 3, 4, 5, 6, 7]) for i in range(dsp.randint(3, 6)) ] for m in range(dsp.randint(2, 5)) ]
try:
notes = dsp.randchoose(melodies)
except IndexError:
dsp.log(melodies)
notes = [1]
if tel['harmonicity'] <= 5:
octave = (tel['register'] / 10.0) * dsp.randint(1, 3) + 1
else:
octave = int(round((tel['register'] / 10.0) * dsp.randint(1, 3) + 1))
bpm = p(voice_id, 'bpm', 80.0)
if 'ballsout' in tel['name']:
length = int((1.0 / (tel['pace'] / 10.0)) * dsp.stf(3))
else:
length = int((1.0 / (tel['pace'] / 10.0)) * dsp.stf(4)) + dsp.stf(dsp.rand(0.25, 1))
# Cap voice length at 60 secs
if length > dsp.stf(60):
length = dsp.stf(60)
env = 'sine'
mod = p(voice_id, 'mod', 'random')
modFreq = p(voice_id, 'modfreq', dsp.rand(1.0, 2.5) / dsp.fts(length))
modRange = dsp.rand(0.01, 0.04)
modRange = dsp.rand(0, modRange)
pulsewidth = 1.0 / (tel['roughness'] / 10.0)
pulsewidth -= dsp.rand(0, 0.09)
if pulsewidth < 0.1:
pulsewidth = 0.1
beat = dsp.bpm2frames(bpm)
try:
freqs = tune.fromdegrees(notes, octave=octave, ratios=tune.just, root='c')
except TypeError:
print 'hm', notes, octave
freqs = tune.fromdegrees([1,5], octave=octave, ratios=tune.just, root='c')
#####################
# NORMAL
#####################
numgrains = int(dsp.rand(50, 500))
if tel['roughness'] <= 2:
window = 'sine'
waveform = 'sine2pi'
minplen = dsp.ftms(length / 4)
maxplen = 30000
elif tel['roughness'] <= 4:
window = 'sine'
waveform = 'sine2pi'
minplen = 10
maxplen = 350
elif tel['roughness'] > 4:
window = 'tri'
waveform = 'tri'
minplen = 10
maxplen = 120
elif tel['roughness'] >= 7:
window = 'vary'
waveform = 'tri'
minplen = 5
maxplen = 80
mod = dsp.wavetable(mod, 512)
window = dsp.wavetable(window, 512)
waveform = dsp.wavetable(waveform, 512)
pc = dsp.breakpoint([ dsp.rand(0, 1) for i in range(int(dsp.rand(5, numgrains))) ], numgrains)
out = ''
outlen = 0
count = 0
bar = dsp.randint(4, 8)
dobeats = tel['density'] > 5 and dsp.rand(0, 100) > 20
if dobeats:
numbeats = bar * dsp.randint(3, 7)
while outlen < length:
layers = []
if dobeats:
plen = beat / dsp.randint(1, 10)
else:
plen = dsp.mstf(dsp.rand(minplen, maxplen))
if tel['register'] >= 6 and tel['density'] >= 4:
maxo = dsp.randint(2, 6)
else:
maxo = 1
if dobeats:
freqs = dsp.randshuffle(freqs)
for b in range(numbeats):
f = freqs[b % len(freqs)]
if dsp.rand(0, 100) > 70:
f *= 2**dsp.randint(0, maxo)
b = dsp.pulsar(f, plen, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
b = dsp.pan(b, dsp.rand())
out += b
outlen += dsp.flen(b)
else:
for iff, freq in enumerate(freqs):
if 'gentle' in tel['name']:
volume = dsp.rand(0.5, 0.6)
elif 'sparse' in tel['name']:
volume = dsp.rand(0.3, 0.6)
elif 'upbeat' in tel['name'] or 'ballsout' in tel['name']:
volume = dsp.rand(0.5, 0.6)
else:
volume = dsp.rand(0.4, 0.6)
if dsp.rand(0, 100) > 60:
freq *= 2**dsp.randint(0, maxo)
layer = dsp.pulsar(freq, plen, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
layer = dsp.env(layer, 'sine')
layer = dsp.pan(layer, dsp.rand())
layers += [ layer ]
layer = dsp.mix(layers)
out += layer
outlen += dsp.flen(layer)
count += 1
out = dsp.env(out, 'sine')
#if dsp.flen(out) > dsp.mstf(100) and dsp.rand(0, 100) > 50:
#out = dsp.drift(out, (tel['harmonicity'] - 10.0) * -1 * 0.1, dsp.randint(4, 441))
dsp.log('')
dsp.log('pulsar')
dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
bot.show_telemetry(tel)
return out
def play(voice_id):
bpm = config('bpm')
beat = dsp.bpm2frames(bpm)
dsl = P(voice_id, 'drum', 'h.c')
length = int(P(voice_id, 'length', dsp.stf(dsp.rand(5, 12))))
volume = P(voice_id, 'volume', 70.0)
volume = volume / 100.0 # TODO move into param filter
octave = P(voice_id, 'octave', 3)
notes = P(voice_id, 'note', '["%s"]' % config('key'))
notes = json.loads(notes)
hertz = P(voice_id, 'hertz', False)
alias = P(voice_id, 'alias', False)
alias = True
bend = P(voice_id, 'bend', False)
env = P(voice_id, 'envelope', 'gauss')
harmonics = P(voice_id, 'harmonic', '[1,2,3,4]')
harmonics = json.loads(harmonics)
reps = P(voice_id, 'repeats', 1)
waveform = P(voice_id, 'waveform', 'sine2pi')
quality = getattr(tune, config('quality'))
ratios = getattr(tune, config('tune'))
glitch = False
#glitch = True
root = 27.5
pinecone = False
bbend = False
wild = False
if bbend == True:
bend = True
tune.a0 = float(root)
# These are amplitude envelopes for each partial,
# randomly selected for each. Not to be confused with
# the master 'env' param which is the amplit
wtypes = ['sine', 'phasor', 'line', 'saw']
layers = []
if hertz is not False:
notes = hertz
for note in notes:
tones = []
for i in range(dsp.randint(2, 4)):
if hertz is not False:
freq = float(note)
if octave > 1:
freq *= octave
else:
freq = tune.ntf(note, octave)
snds = [
dsp.tone(length, freq * h, waveform, 0.05) for h in harmonics
]
snds = [
dsp.env(s, dsp.randchoose(wtypes), highval=dsp.rand(0.3, 0.6))
for s in snds
]
snds = [dsp.pan(s, dsp.rand()) for s in snds]
if bend is not False:
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)
snds = [bendit(snd) for snd in snds]
tones += [dsp.mix(snds)]
layer = dsp.mix(tones)
if wild != False:
layer = dsp.vsplit(layer, 41, 4410)
layer = [dsp.amp(dsp.amp(l, dsp.rand(10, 20)), 0.5) for l in layer]
layer = ''.join(layer)
if pinecone != False:
layer = dsp.pine(layer, length, freq, 4)
if glitch == True:
layer = dsp.vsplit(layer, dsp.mstf(10), dsp.flen(layer) / 4)
layer = dsp.randshuffle(layer)
layer = ''.join(layer)
layer = dsp.env(layer, env)
layers += [layer]
out = dsp.mix(layers) * reps
return dsp.amp(out, volume)
def play(ctl):
mpk = ctl.get('midi').get('mpk')
ccs = [i + 48 for i in range(24)]
notes = []
for cc in ccs:
if mpk.get(cc) < 1:
notes += [cc]
ssnd = dsp.read('/home/hecanjog/sounds/drums/78sd.wav').data
ssnd = dsp.read('jesssnare.wav').data
hsnd = dsp.read('/home/hecanjog/sounds/drums/Shaker.wav').data
ksnd = dsp.read('/home/hecanjog/sounds/drums/Drybd2.wav').data
#ksnd = dsp.read('jesskick.wav').data
beat = dsp.bpm2frames(90)
#beat = dsp.mstf(290 * 2)
length = beat * 4
hat = 'xxx '
kick = 'x '
snare = ' x '
#snare = ' x xx'
#snare = ' '
def makeHat(length, i, amp):
h = hsnd
h = dsp.env(h, 'phasor')
h = dsp.pad(h, 0, length - dsp.flen(h))
return h
def makeKick(length, i, amp):
k = dsp.mix([ksnd, drums.sinekick(length, i, amp)])
#k = dsp.env(ksnd, 'phasor')
k = dsp.fill(k, length, silence=True)
k = dsp.amp(k, 1)
return k
def makeSnare(length, i, amp):
s = ssnd
s = dsp.amp(s, 1.2)
s = dsp.transpose(s, dsp.rand(1.5, 3))
s = dsp.fill(s, length, silence=True)
#ss = dsp.drift(s, dsp.rand(0.001, 0.1))
#s = dsp.mix([s, ss])
return s
#hats = drums.parsebeat(hat, 16, beat, length, makeHat, 25)
hats = drums.parsebeat(hat, 16, beat, length, makeHat, 0)
kicks = drums.parsebeat(kick, 16, beat, length, makeKick, 0)
snares = drums.parsebeat(snare, 8, beat, length, makeSnare, 0)
out = dsp.mix([hats, kicks, snares])
shuf = True
shuf = False
if shuf:
out = dsp.split(out, beat)
out = dsp.randshuffle(out)
out = ''.join(out)
out = dsp.amp(out, 2)
cuts = True if dsp.rand() > 0.5 else False
cuts = True
#cuts = False
if cuts:
o = dsp.split(out, beat / 2)
o = dsp.randshuffle(o)
o = [dsp.amp(oo, dsp.rand(0, 2.5)) for oo in o]
o = [dsp.env(oo, 'random') for oo in o]
out = dsp.mix([''.join(o), out])
dsp.log(notes)
synthy = False
#synthy = True
if synthy == True:
s = ''
for ii in range(dsp.flen(out) / (beat / 2)):
layers = []
if len(notes) > 0:
scale = [n - 47 for n in notes]
scale = [1, 5, 8, 12]
scale = tune.fromdegrees(scale, octave=3, root='d')
p = ''.join([
keys.pulsar(scale[ii % len(scale)],
pulsewidth=dsp.rand(0.1, 1),
amp=0.5,
length=(beat / 2) / 3) for _ in range(3)
])
layers += [p]
else:
layers += [dsp.pad('', beat / 2, 0)]
s += dsp.mix(layers)
out = dsp.mix([s, out])
#out = dsp.alias(out)
#out = dsp.drift(out, dsp.rand(0.5, 2))
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)
amp = dsp.rand(0.1, 0.65)
nlens = [
beat * 4,
beat * 3,
beat * 2,
beat + (beat / 2),
beat,
beat / 2,
beat / 4,
]
scale = [2,4,6,9]
scale = [1,4,6,8]
# scale = [1,3,4,5,6,8,9]
# scale = [1,2,3,5,6,8,9]
# scale = [1,5,8]
freqs = tune.fromdegrees(scale, root=root, octave=dsp.randint(2,4), ratios=ratios, scale=quality)
# length of pattern (in beats)
elen = 0
tlen = beat * dsp.randint(2, 8)
# beat lengths (from a set of bpm-derived note lengths defined in the nlens list)
blens = []
while elen < tlen:
l = dsp.randchoose(nlens)
blens += [ l ]
elen += l
# beat pulsewidths
bpws = [ dsp.rand(0.1, 1) for pw in range(len(blens)) ]
out = ''
# choose a pitch from the scale
freq = dsp.randchoose(freqs)
# synthesize the tones
for i in range(len(blens)):
# find the length of the pulse
blen = int(round(blens[i] * bpws[i]))
# find the length of the rest
brest = blens[i] - blen
# make a rhodes tone with a random amplitude
#beat = keys.rhodes(length=blen, freq=freq, amp=dsp.rand(0.3, 0.5))
beat = keys.rhodes(length=blen, freq=freq, amp=amp)
# pan the tone to a random position
beat = dsp.pan(beat, dsp.rand())
# bitcrush the tone a random amount
# beat = dsp.alias(beat)
# pad the tone with silence
beat = dsp.pad(beat, 0, brest)
# add it to the output
out += beat
out *= dsp.randint(1, 2)
if dsp.rand() > 0.75:
out = dsp.split(out, dsp.bpm2frames(bpm) / dsp.randchoose([1,2,4]))
out = dsp.randshuffle(out)
out = ''.join(out)
return out
layers = dsp.mix(layers)
ctf = tune.fromdegrees([commontone], octave=2, root='c')[0]
drone = dsp.mix([
keys.pulsar(ctf, dsp.flen(layers), amp=dsp.rand(0.01, 0.1))
for _ in range(4)
])
chord = nextChord(chord)
if b % 2 == 0:
commontone = commontone + dsp.randchoose([-1, 1])
if commontone == 0:
commontone = 1
layers = dsp.split(layers, beat / 3)
layers = dsp.randshuffle(layers)
layers = ''.join(layers)
drone = dsp.split(drone, beat)
drone = dsp.randshuffle(drone)
drone = ''.join(drone)
hats = drums.parsebeat(hatp, 16, beat, dsp.flen(layers), makeHat, 12)
kicks = drums.parsebeat(kickp, 4, beat, dsp.flen(layers), makeKick, 0)
snares = drums.parsebeat(snarep, 8, beat, dsp.flen(layers), makeSnare, 0)
dr = dsp.mix([kicks, snares])
d = dsp.split(dr, beat / 8)
d = dsp.randshuffle(d)
d = [dd * dsp.randint(1, 2) for dd in d]
layer = dsp.pan(layer, dsp.rand())
layers += [ layer ]
layers = dsp.mix(layers)
ctf = tune.fromdegrees([ commontone ], octave=2, root='c')[0]
drone = dsp.mix([ keys.pulsar(ctf, dsp.flen(layers), amp=0.3) for _ in range(4) ])
chord = nextChord(chord)
if b % 2 == 0:
commontone = commontone + dsp.randchoose([-1,1])
if commontone == 0:
commontone = 1
layers = dsp.split(layers, beat / 3)
layers = dsp.randshuffle(layers)
layers = ''.join(layers)
drone = dsp.split(drone, beat)
drone = dsp.randshuffle(drone)
drone = ''.join(drone)
#hats = dsp.fill(dsp.fill(hat, beat / 4), dsp.flen(layers))
#kicks = dsp.fill(kick, dsp.flen(layers), silence=True)
hats = drums.parsebeat(hatp, 8, beat, dsp.flen(layers), makeHat, 12)
kicks = drums.parsebeat(kickp, 4, beat, dsp.flen(layers), makeKick, 0)
snares = drums.parsebeat(snarep, 8, beat, dsp.flen(layers), makeSnare, 0)
#dr = dsp.mix([ hats, kicks, snares ])
dr = dsp.mix([ kicks, snares ])
from pippi import dsp
main = dsp.read('base_loop.wav').data
synth = dsp.read('synthloop.wav').data
beat = dsp.flen(main) / 128
freq = 430
s = dsp.pine(synth, dsp.flen(main) * 8, freq)
s = dsp.split(s, beat)
s = dsp.randshuffle(s)
s = [ dsp.alias(ss) for ss in s ]
s = [ dsp.amp(ss, dsp.rand(0.5, 2)) 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.split(synth, beat)
s2 = dsp.randshuffle(s2)
s2 = [ dsp.transpose(ss, dsp.randchoose([1,2,4])) for ss in s2 ]
s2 = [ dsp.fill(ss, beat) for ss in s2 ]
s2 = [ dsp.env(ss, 'phasor') for ss in s2 ]
s2 = ''.join(s2)
synth = dsp.mix([ s, s2 ])
synth = dsp.fill(synth, dsp.flen(main))
#synth = dsp.fill(synth, dsp.flen(main))
out = dsp.mix([ main, synth ])
#out = synth
