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 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 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 rhodes(total_time, freq=220.0, ampscale=0.5): 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: partial = dsp.tone(freq=plist[0] * freq, length=total_time, amp=plist[1] * ampscale) env_length = (total_time * plist[2] * 2) / 32 wtable = dsp.wavetable('hann', int(env_length)) wtable = wtable[int(env_length / 2):] wtable.extend([0 for i in range(total_time - len(wtable))]) print env_length, len(wtable), dsp.flen(partial) partial = dsp.split(partial, 32) partial = [dsp.amp(partial[i], wtable[i]) for i in range(len(partial))] layer = ''.join(partial) layers += [layer] out = dsp.mix(layers) noise = dsp.amp(dsp.bln(dsp.flen(out) * 2, 2000, 20000), 0.005) noise = dsp.fill(noise, dsp.flen(out)) out = dsp.mix([out, noise]) return out
def rhodes(total_time, freq=220.0, ampscale=0.5): 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: partial = dsp.tone(freq=plist[0] * freq, length=total_time, amp=plist[1] * ampscale) env_length = (total_time * plist[2] * 2) / 32 wtable = dsp.wavetable('hann', int(env_length)) wtable = wtable[int(env_length / 2):] wtable.extend([0 for i in range(total_time - len(wtable))]) print env_length, len(wtable), dsp.flen(partial) partial = dsp.split(partial, 32) partial = [ dsp.amp(partial[i], wtable[i]) for i in range(len(partial)) ] layer = ''.join(partial) layers += [ layer ] out = dsp.mix(layers) noise = dsp.amp(dsp.bln(dsp.flen(out) * 2, 2000, 20000), 0.005) noise = dsp.fill(noise, dsp.flen(out)) out = dsp.mix([out, noise]) return out
def rhodes(length=22050, freq=220.0, amp=0.5, wavetype='sine'): 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: partial = dsp.tone(freq=plist[0] * freq, length=length, amp=plist[1], wavetype=wavetype) env_length = (length * plist[2] * 2) / 32 if env_length <= 2: env_length = 4 wtable = dsp.wavetable('hann', int(env_length)) wtable = wtable[int(env_length / 2):] wtable.extend([0 for i in range(length - len(wtable))]) partial = dsp.split(partial, 32) partial = [ dsp.amp(partial[i], wtable[i]) for i in range(len(partial)) ] layer = ''.join(partial) layers += [ layer ] out = dsp.mix(layers) noise = dsp.amp(dsp.bln(dsp.flen(out) * 2, 2000, 20000), 0.005) noise = dsp.fill(noise, dsp.flen(out)) out = dsp.mix([out, noise]) out = dsp.amp(out, amp) return out
def bell(length=22050, freq=220, amp=0.5): ding = dsp.read('/home/hecanjog/sounds/vibesc1.wav').data ding = dsp.amp(ding, dsp.rand(0.5, 0.8)) bell = dsp.read('/home/hecanjog/sounds/tones/bellc.wav').data bell = dsp.amp(bell, dsp.rand(10, 50)) bell = dsp.amp(bell, 0.3) rhodes = dsp.read('/home/hecanjog/sounds/tones/rhodes.wav').data rhodes = dsp.transpose(rhodes, 1.2) rhodes = dsp.pan(rhodes, dsp.rand()) glade = dsp.read('/home/hecanjog/sounds/glade.wav').data numgs = dsp.randint(2, 6) gs = [] for _ in range(numgs): g = dsp.rcut(glade, dsp.mstf(100, 500)) g = dsp.amp(g, dsp.rand(0.2, 0.5)) g = dsp.pan(g, dsp.rand()) g = dsp.transpose(g, dsp.rand(0.15, 0.75)) gs += [ g ] gs = dsp.mix(gs) gs = dsp.env(gs, 'phasor') clump = dsp.mix([ ding, gs, bell, rhodes ]) clump = dsp.transpose(clump, freq / tune.ntf('c', octave=4)) clump = dsp.fill(clump, length, silence=True) clump = dsp.env(clump, 'phasor') clump = dsp.amp(clump, amp) return clump
def play(args): length = dsp.stf(0.2) volume = 0.2 octave = 2 notes = ['d', 'a'] quality = tune.major waveform = 'sine' ratios = tune.terry wtypes = ['sine', 'phasor', 'line', 'saw'] for arg in args: a = arg.split(':') if a[0] == 't': length = dsp.stf(float(a[1])) if a[0] == 'v': volume = float(a[1]) / 100.0 if a[0] == 'o': octave = int(a[1]) if a[0] == 'n': notes = a[1].split('.') if a[0] == 'q': if a[1] == 'M': quality = tune.major elif a[1] == 'm': quality = tune.minor else: quality = tune.major if a[0] == 'tr': ratios = getattr(tune, a[1], tune.terry) harm = range(1, 12) layers = [] for note in notes: freq = tune.ntf(note, octave, ratios) #tonic = dsp.env(dsp.amp(dsp.tone(length, freq, 'sine2pi'), 0.2), 'phasor') * 500 tones = [] for t in range(4): angles = dsp.breakpoint([ freq * dsp.randchoose(harm) for f in range(dsp.randint(2, 20)) ], 100) angles = [ dsp.env(dsp.tone(length, a, 'sine2pi'), 'sine', amp=0.2) for a in angles ] tones += [ ''.join(angles) ] #layer = dsp.benv(dsp.mix(tones), [ dsp.rand(0.1, 0.7) for i in range(dsp.randint(5, 30)) ]) layers += [ dsp.mix(tones) ] #layers += [ dsp.mix([layer, tonic]) ] #layers += [ layer ] out = dsp.mix(layers) return dsp.amp(out, volume)
def 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') 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 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 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 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 chord(length, freqs, amp): layers = [ keys.rhodes(length, freq, amp * dsp.rand(0.25, 0.5)) for freq in freqs ] layers = [dsp.pan(layer, dsp.rand()) for layer in layers] return dsp.mix(layers)
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 makeKick(length, i): k = dsp.randchoose([ kickhard, kicksoft ]) k = dsp.mix([ k, dsp.env(sock, 'phasor') ]) if dsp.rand() > 0.4: k = dsp.env(k, 'phasor') return dsp.fill(k, length, silence=True)
def 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 arp_synth(length, pos, total_length): seg = [ BEAT for _ in range(int(length//BEAT)) ] 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()) # Lead synth arps = dsp.mix([ makeArps(seg, dsp.randint(1,3), dsp.randint(3, 4)) for a in range(dsp.randint(1, 4)) ]) arps = mixdrift(arps) return arps
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 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 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 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 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 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 test_split(self): g = dsp.read('tests/sounds/guitar1s.wav') bands = multiband.split(g, 3) for i, b in enumerate(bands): b.write('tests/renders/multiband_split-band%02d.wav' % i) out = dsp.mix(bands) out = fx.norm(out, 1) out.write('tests/renders/multiband_split-reconstruct.wav')
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 clap(amp, length): if amp == 0: return dsp.buffer(length=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 = out.env('phasor').pad(end=length - out.dur) return out
def makePaper(out): tail = dsp.cut(paper, dsp.mstf(60), dsp.flen(out) - dsp.mstf(60)) tail = [ dsp.transpose(tail, dsp.rand(0.95, 1.05)) for _ in range(dsp.randint(3,6)) ] tail = [ fx.penv(t) for t in tail ] out = dsp.mix(tail + [ out ]) return out
def makeSnare(length, i, amp): s = ssnd s = dsp.amp(s, 10) s = dsp.transpose(s, dsp.rand(0.8, 1)) s = dsp.fill(s, length, silence=True) ss = dsp.drift(s, dsp.rand(0.001, 0.1)) s = dsp.mix([s, ss]) return s
def test_customsplit(self): g = dsp.read('tests/sounds/guitar1s.wav') freqs = [400, 3000, 3005, 10000] bands = multiband.customsplit(g, freqs) for i, b in enumerate(bands): b.write('tests/renders/multiband_customsplit-band%02d.wav' % i) out = dsp.mix(bands) out = fx.norm(out, 1) out.write('tests/renders/multiband_customsplit-reconstruct.wav')
def mix(self, length=None): self.tracks = sorted(self.tracks, key=lambda x: dsp.flen(x)) #self.tracks.reverse() out = dsp.mix(self.tracks) if length is not None: out = dsp.fill(out, length) return out
def makeSnare(length, i): burst = dsp.bln(length, dsp.rand(400, 800), dsp.rand(8000, 10000)) burst = dsp.env(burst, 'phasor') s = dsp.mix([snare, burst]) s = dsp.transpose(s, dsp.rand(0.9, 1.1)) s = dsp.fill(s, length, silence=True) return dsp.taper(s, 40)
def snare(amp, length): if amp == 0: return dsp.buffer(length=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 = out.env('phasor') out = out.pad(end=length - out.dur) return out
def brass(length=22050, freq=220, amp=0.5): pw = dsp.rand(0.25, 0.5) note = pulsar(length=length, freq=freq, pulsewidth=pw, amp=amp) noise = dsp.bln(length, dsp.rand(1000, 2000), dsp.rand(2000, 3000)) noise = dsp.fill(noise, length) noise = fx.bend(noise, [ dsp.rand() for _ in range(dsp.randint(5, 10)) ], dsp.rand(0.01, 0.3)) noise = dsp.amp(noise, dsp.rand(0.001, 0.002)) noise = dsp.env(noise, 'tri') note = dsp.mix([ note, noise ]) return note
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 rain(snd, freqs): layers = [] for freq in freqs: #layer = dsp.pine(snd, dsp.flen(snd) * 16, freq) layer = dsp.pan(snd, dsp.rand()) layer = dsp.amp(layer, 0.5) layer = dsp.alias(layer) layers += [ layer ] return dsp.mix(layers)
def snare(amp, length): if amp == 0: return dsp.pad('', 0, length) # Two layers of noise: lowmid and high out = dsp.mix([ dsp.bln(int(length * 0.2), 700, 3200, 'impulse'), dsp.bln(int(length * 0.01), 7000, 9000) ]) out = dsp.env(out, 'phasor') out = dsp.pad(out, 0, length - dsp.flen(out)) out = dsp.amp(out, amp) 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 makeLong(seg): g = dsp.randchoose(guitars) g = dsp.amp(g, 0.4) long_guitar = dsp.fill(g, sum(seg)) fade_guitar = dsp.randchoose(guitars) fade_guitar = dsp.amp(fade_guitar, dsp.rand(0.1, 0.3)) fade_guitar = fx.penv(fade_guitar) fade_guitar = dsp.fill(fade_guitar, sum(seg)) out = dsp.mix([ long_guitar, fade_guitar ]) return out
def makeLong(seg): g = dsp.randchoose(guitars) g = dsp.amp(g, 0.4) long_guitar = dsp.fill(g, sum(seg)) fade_guitar = dsp.randchoose(guitars) fade_guitar = dsp.amp(fade_guitar, dsp.rand(0.1, 0.3)) fade_guitar = fx.penv(fade_guitar) fade_guitar = dsp.fill(fade_guitar, sum(seg)) out = dsp.mix([long_guitar, fade_guitar]) return out
def clap(amp, length): if amp == 0: return dsp.pad('', 0, 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 clap(amp, length): if amp == 0: return dsp.pad('', 0, length) # Two layers of noise: lowmid and high lowlow, lowhigh = dsp.rand(300, 600), dsp.rand(700, 1200) highlow, highhigh = dsp.rand(3000, 7000), dsp.rand(7000, 9000) out = dsp.mix([ dsp.bln(int(length * 0.2), lowlow, lowhigh), dsp.bln(int(length * 0.2), 7000, 9000) ]) out = dsp.env(out, 'phasor') out = dsp.pad(out, 0, length - dsp.flen(out)) out = dsp.amp(out, amp) return out
def makeTails(self, freq, length): freq *= 0.5 harmonics = [ dsp.randint(1, 8) for _ in range(2, 4) ] layers = [] for harmonic in harmonics: layer = dsp.tone(length, freq * harmonic, amp=dsp.rand(0.1, 0.3)) layer = fx.penv(layer) layer = dsp.env(layer, 'sine') layers += [ layer ] layers = dsp.mix(layers) layers = dsp.amp(layers, dsp.rand(0.25, 1)) return layers
def snare(amp, length): if amp == 0: return dsp.pad('', 0, 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 glitchPulse(snd): """ 2 to 3 overlapping streams of enveloped grains at regular but phasing intervals. """ numlayers = dsp.randint(2,3) layers = [] for _ in range(numlayers): grains = dsp.split(snd, dsp.mstf(1, 100)) grains = [ dsp.taper(g, 50) for g in grains ] grains = ''.join(grains) grains = penv(grains) layers += [ grains ] return dsp.mix(layers)
def play(ctl): param = ctl.get('param') lpd = ctl.get('midi').get('lpd') freqs = [25, 55, 109, 222, 440, 550, 660, 770, 880] freqs = [55, 110, 440, 220, 880] length = dsp.mstf(dsp.rand(100, 2000)) length = dsp.mstf(3000) layers = [] for freq in freqs: freq = freq * 4 + dsp.rand(0.1, 1.5) if freq < 100: amp = 0.3 else: amp = 0.01 layer = dsp.mix([ dsp.tone(length, freq, amp=amp), dsp.tone(length, freq + dsp.rand(1, 10), amp=amp) ]) layers += [ layer ] out = dsp.mix(layers) 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(ctl): mpk = ctl.get('midi').get('mpk') nk = ctl.get('midi').get('nk') amp = mpk.get(4, low=0, high=1, default=0) kick = dsp.read('/home/hecanjog/sounds/drums/Junglebd.wav').data klength = dsp.mstf(mpk.get(1, low=60, high=1500, default=100)) k = dsp.fill(kick, klength, silence=True) kamp = nk.get(0, low=0, high=1, default=1) k = dsp.amp(k, kamp) kpitch = nk.get(16, low=0.25, high=1, default=1) k = dsp.transpose(k, kpitch) snare = dsp.read('/home/hecanjog/sounds/drums/Hipclap1.wav').data slength = dsp.mstf(mpk.get(2, low=60, high=500, default=100)) s = dsp.fill(snare, slength, silence=True) soffset = dsp.mstf(mpk.get(6, low=0, high=500, default=0)) s = dsp.pad(s, soffset, 0) samp = nk.get(1, low=0, high=1, default=1) s = dsp.amp(s, samp) spitch = nk.get(17, low=0.25, high=2, default=1) s = dsp.transpose(s, spitch) hat = dsp.read('/home/hecanjog/sounds/drums/78ch.wav').data hlength = dsp.mstf(mpk.get(3, low=60, high=500, default=100)) h = dsp.fill(hat, hlength, silence=True) hoffset = dsp.mstf(mpk.get(7, low=0, high=500, default=0)) h = dsp.pad(h, hoffset, 0) hamp = nk.get(2, low=0, high=1, default=1) h = dsp.amp(h, hamp) hpitch = nk.get(18, low=0.25, high=2, default=1) h = dsp.transpose(h, hpitch) longest = max([dsp.flen(k), dsp.flen(h), dsp.flen(s)]) k = dsp.fill(k, longest) h = dsp.fill(h, longest) s = dsp.fill(s, longest) out = dsp.mix([k, s, h]) out = dsp.amp(out, amp) return out
def play(ctx): freq = ctx.p.freq or 330.0 length = ctx.p.length or 0.1 amp = dsp.rand(0.1, 0.35) out = make_note(freq, amp, length) cld = out.cloud( length, window='sine', position='rnd', grid=dsp.win('rnd', 0.1, 2), grainlength=dsp.win('rnd', dsp.MS * 10, dsp.MS * 100), speed=dsp.win('rnd', 0.5, 2), ) out = dsp.mix([out, cld]) out = out.adsr(dsp.rand(0.01, 0.02), 0.01, 0.5, 0.1) yield 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 grain_synth(length, pos, total_length): notes = [ rhodes.rhodes(dsp.rand(4, 7), freq, 0.3) for freq in scale ] themes = [ [ note.speed(dsp.choice(speeds)) for note in notes * 2 ] for theme in range(8) ] theme = dsp.choice(themes) theme_note = dsp.choice(theme) def makeGrains(snd): envs = ['tri', 'phasor', 'rsaw', 'sine', 'hann'] grains = [] for g in snd.grains(dsp.MS*20, dsp.MS*90): g = g.env('hann').pan(dsp.rand()).taper(dsp.MS*4) grains += [ g ] rgrains = [] while len(grains) > 0: r = grains.pop(dsp.randint(0, len(grains)-1)) rgrains += [ r ] out = dsp.join(rgrains) out = out.env(dsp.choice(envs)) return out if dsp.rand() > 0.5: gnote = theme_note.speed(1.5) else: gnote = theme_note grains = [ makeGrains(gnote) for g in range(dsp.randint(4, 10)) ] for gi, grain in enumerate(grains): if dsp.rand() > 0.5: grains[gi] = grain.speed(2).taper(0.01).repeat(2) grains = dsp.mix(grains) grains = grains * dsp.rand(0.25, 0.55) grains = mixdrift(grains) return grains
from pippi import dsp freqs = [55, 220, 440, 770] length = dsp.stf(90) layers = [] for freq in freqs: amp = dsp.rand(0.05, 0.1) wf1 = dsp.breakpoint([ dsp.rand(-1, 1) for p in range(7) ], 512) wf2 = dsp.breakpoint([ dsp.rand(-1, 1) for p in range(4) ], 512) layer = dsp.subtract(dsp.ctone(freq * 0.999, length, wf1, amp), dsp.ctone(freq, length, wf2, amp)) layer = dsp.pan(layer, dsp.rand()) layer = dsp.env(layer, 'random') layers += [ layer ] out = dsp.mix(layers) dsp.write(out, 'retabler2')
def play(ctl): param = ctl.get('param') lpd = ctl.get('midi').get('lpd') scale = [ dsp.randchoose([1, 3, 5, 6, 8]) for s in range(dsp.randint(2, 4)) ] #scale = [ dsp.randchoose([1, 2, 4, 6, 8]) for s in range(dsp.randint(2, 4)) ] freqs = tune.fromdegrees(scale, root='a', octave=dsp.randint(2,3), scale=tune.minor) freq = dsp.randchoose(freqs) pw = lpd.get(2, low=0.01, high=1, default=1) pw = dsp.rand(0.01, 1) modr = lpd.get(6, low=0.001, high=0.1) modr = dsp.rand(0.001, 0.05) #modr = dsp.rand(0.1, 10.5) #modr = dsp.rand(0.001, 0.01) modr = dsp.rand(0, modr) modf = dsp.rand(0.01, 0.05) amp = lpd.get(1, low=0, high=2, default=0) #amp = dsp.rand(0.1, 0.5) #amp = 0 length = dsp.stf(lpd.get(5, low=0.5, high=14, default=1) * dsp.rand(0.75, 2)) length = dsp.stf(dsp.rand(5.5, 24) * dsp.rand(0.75, 2)) #length = dsp.stf(dsp.rand(0.5, 0.75) * dsp.rand(0.75, 2)) wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for w in range(10) ] + [0], 512) #wf = dsp.wavetable('sine2pi', 512) #wf = dsp.wavetable('sine2pi', 512) #win = dsp.wavetable('sine', 512) win = dsp.breakpoint([0] + [ dsp.rand(0, 1) for w in range(5) ] + [0], 512) mod = dsp.breakpoint([0] + [ dsp.rand(0, 1) for m in range(5) ] + [0], 512) layers = [] harmonics = [1, 2, 3, 4] for harmonic in harmonics: f = freq * harmonic if harmonic > 4: a = dsp.rand(0.05, 0.1) else: a = amp * dsp.rand(0.1, 0.5) layer = dsp.pulsar(f, length, pw, wf, win, mod, modr, modf, a * 2) layer = dsp.env(layer, dsp.randchoose(['sine', 'tri', 'line', 'phasor'])) layer = dsp.taper(layer) layer = dsp.pan(layer, dsp.rand()) layer = dsp.mix([ dsp.drift(layer, dsp.rand(0.01, 0.03)), layer ]) if dsp.rand() > 0.5: layer = dsp.vsplit(layer, dsp.mstf(50), dsp.mstf(500)) bit = dsp.randchoose(layer) bit = bit * dsp.randint(1, 3) bit = dsp.transpose(bit, dsp.randchoose([1, 2, 4, 8])) layer = ''.join(layer) layer = dsp.insert_into(layer, bit, dsp.randint(0, dsp.flen(layer) - dsp.flen(bit))) layers += [ layer ] out = dsp.mix(layers) out = dsp.env(out, 'sine') out = dsp.env(out, 'hann') #out = dsp.env(out, 'phasor') out = dsp.taper(out) return out
def play(ctl): param = ctl.get('param') lpd = ctl.get('midi').get('lpd') pc = ctl.get('midi').get('pc') #pc.setOffset(111) gamut = { 'high': [ (10000, 15000), (5000, 15000), (5000, 10000), ], 'mid': [ (1000, 5000), (1000, 2000), ], 'pitch': [ tuple([ dsp.rand(500, 2000) for p in range(2) ]), tuple([ dsp.rand(100, 1000) for p in range(2) ]), tuple([ dsp.rand(1000, 5000) for p in range(2) ]), ], 'low': [ (20, 5000), (30, 10000), (40, 10000), ] } area = param.get('wash-area', default='high') area = dsp.randchoose(['high', 'mid', 'pitch', 'low']) area = 'pitch' dsp.log(area) freqs = dsp.randchoose(gamut[area]) freqscale = pc.get(16, low=0.125, high=2, default=1) #freqscale = dsp.rand(0.125, 2) low = freqs[0] * freqscale high = freqs[1] * freqscale wform = dsp.randchoose(['sine2pi', 'tri', 'vary', 'square']) timescale = pc.get(17, low=1, high=4, default=1) #timescale = dsp.rand(1, 4) lengthscale = pc.get(18, low=0.125, high=2.5) #lengthscale = dsp.rand(0.125, 2.5) amp = pc.get(0, low=0, high=0.5, default=0.5) #amp = dsp.rand(0, 0.5) if area == 'high': low = dsp.rand(low * 0.9, low) high = dsp.rand(high, high * 1.1) length = dsp.stf(dsp.rand(0.01, 0.3) * lengthscale) out = dsp.bln(length, low, high, wform) out = dsp.env(out, 'phasor') if dsp.rand() > 10.5: beep = dsp.tone(dsp.flen(out), high * 2, amp=dsp.rand(0.5, 1)) out = dsp.mix([out, beep]) out = dsp.pad(out, 0, dsp.mstf(dsp.rand(1, 400) * timescale)) out = out * dsp.randint(1, 3) out = dsp.drift(out, dsp.rand(0, 1)) elif area == 'mid': low = dsp.rand(low * 0.9, low) high = dsp.rand(high, high * 1.1) length = dsp.stf(dsp.rand(0.01, 0.5) * lengthscale) out = dsp.bln(length, low, high, wform) out = dsp.env(out, 'random') if timescale > 1: out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5))) elif area == 'pitch': low = dsp.rand(low * 0.9, low) high = dsp.rand(high, high * 1.1) length = dsp.stf(dsp.rand(0.01, 0.5) * lengthscale) out = dsp.bln(length, low, high, wform) out = dsp.env(out, 'random') if timescale > 1: out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5))) elif area == 'low': low = dsp.rand(low * 0.9, low) high = dsp.rand(high, high * 1.1) length = dsp.stf(dsp.rand(0.2, 2) * lengthscale) out = dsp.bln(length, low, high, wform) out = dsp.env(out, 'random') out = dsp.mix([out, dsp.tone(length, low)]) if dsp.rand() > 0.5: beep = dsp.tone(dsp.flen(out), high, amp=dsp.rand(0.015, 0.1), wavetype=dsp.randchoose(['hann', 'impulse', 'square', 'vary', 'sine'])) out = dsp.mix([out, beep]) if timescale > 1: out = dsp.pad(out, 0, dsp.mstf(500 * timescale * dsp.rand(0.5, 1.5))) if dsp.rand() > pc.get(19, low=0, high=1, default=0.75): plength = length * dsp.randint(2, 6) freq = tune.ntf(param.get('key', default='c'), octave=dsp.randint(0, 4)) out = dsp.mix([ dsp.pine(out, plength, freq), dsp.pine(out, plength, freq * 1.25) ]) out = dsp.fill(out, length) out = dsp.pan(out, dsp.rand()) out = dsp.amp(out, amp) return out
minlen = 40 lenrange = dsp.rand(300, 500) lengths = dsp.wavetable('hann', 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) layers += [ (lengths, pans) ] sections += [ layers ] out = '' for section in sections: layers = [] for layer in section: startpoint = dsp.randint(0, dsp.flen(g) - max(layer[0])) grains = '' for l, p in zip(layer[0], layer[1]): grain = dsp.cut(g, startpoint, l) grain = dsp.env(grain, 'phasor') grain = dsp.taper(grain, dsp.mstf(10)) grain = dsp.pan(grain, p) grains += grain layers += [ dsp.env(grains, 'phasor') ] out += dsp.mix(layers) dsp.write(out, 'spiderfall')
boids = [[dsp.rand(0, 1) for _ in range(numpoints + 1)] for b in range(numboids)] for p in range(numpoints - 1): center = 0 for b in boids: center += b[p] center = center / float(numboids) for i, b in enumerate(boids): boids[i][p + 1] = boids[i][p] - ((center - boids[i][p]) / 1000.0) out = [] freq = 300 wf = dsp.wavetable('sine2pi', 512) win = dsp.wavetable('hann', 512) length = dsp.stf(60) pw = 1 modrange = 300 modfreq = 1.0 / 60 for b in boids: out += [dsp.pulsar(freq, length, pw, wf, win, b, modrange, modfreq, 0.1)] out = dsp.mix(out) dsp.write(out, 'boids')
def make(length, i): return dsp.taper(dsp.fill(dsp.mix([bigkick, kick]), length, silence=True), 40)
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
p = dsp.taper(p, 20) p = dsp.amp(p, amp) p = dsp.pan(p, pan) layer += p layers += [layer] freqs = tune.fromdegrees([dsp.randint(1, 9) for _ in range(nlayers)], octave=1, root='a') for i, freq in enumerate(freqs): layers[i] = dsp.pine(layer, dsp.flen(layer) * 10, freq) section = dsp.fill(dsp.mix(layers), sectionlength) plen = dsp.randint(16, 32) pattern = dsp.eu(plen, dsp.randint(4, plen)) pattern = ['x' if h == 1 else '.' for h in pattern] beat = dsp.flen(section) / plen kicks = ctl.makeBeat(pattern, [beat for _ in range(plen)], makeKick) pattern = 'x..' rimshots = ctl.makeBeat(pattern, [dsp.flen(section) / 16 for _ in range(16)], makeRimshot) pattern = ctl.parseBeat('xxxx') pdiv = dsp.randint(32, 64) hats = ctl.makeBeat(pattern,