def makeKicks(length, wobble): out = Tracks() onsets = makeOnsets(length, wobble, 2, 4, True) kick = dsp.taper(k, 20) kick = dsp.transpose(kick, dsp.rand(1, 2)) for onset in onsets: out.add(kick, onset) out = out.mix() 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 makeSnare(length, i, amp): s = dsp.cut(snare, 0, dsp.randint(dsp.mstf(40), dsp.flen(snare))) s = dsp.alias(s, dsp.randint(4, 12)) s = dsp.taper(s) s = dsp.fill(s, length, silence=True) s = dsp.amp(s, dsp.rand(2, 4)) return s
def makeSnare(length, i, amp): s = dsp.cut(snare, 0, dsp.randint(dsp.mstf(40), dsp.flen(snare))) s = dsp.alias(s, dsp.randint(4, 12)) s = dsp.taper(s) s = dsp.fill(s, length, silence=True) s = dsp.amp(s, dsp.rand(2,4)) return s
def makeStab(length, i): freqs = tune.fromdegrees([ dsp.randchoose([1,2,3,4,5,6,8]) for _ in range(dsp.randint(2,4)) ], octave=3, root=key) stab = chord(length, freqs, dsp.rand(0.25, 0.75)) stab = dsp.taper(stab, 40) stab = dsp.fill(stab, length, silence=True) return stab
def glitchStutter(snd): """ Basically a random gate """ snd = dsp.vsplit(snd, dsp.mstf(1, 50), dsp.mstf(50, 200)) for i, s in enumerate(snd): if dsp.rand() > dsp.rand(0.5, 0.9): s = dsp.amp(s, dsp.rand(0, 0.15)) s = dsp.taper(s, 20) snd[i] = s else: s = dsp.amp(s, dsp.rand(0.85, 1)) snd[i] = dsp.taper(s, 20) snd = ''.join(snd) return snd
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 makeStab(length, i): chord = tune.fromdegrees([ dsp.randchoose([1,4,5,8]) for _ in range(dsp.randint(2,4)) ], octave=3, root=key) stab = rhodesChord(length, chord, dsp.rand(0.5, 0.75)) stab = dsp.taper(stab, 40) stab = dsp.fill(stab, length, silence=True) return stab
def makeGrains(): guitar = dsp.randchoose(guitars) guitar = dsp.transpose(guitar, dsp.randchoose([1, 2, 3, 4, 8])) max_grain_length = dsp.mstf(dsp.rand(10, 500)) positions = [ math.floor(pos * (dsp.flen(guitar) - max_grain_length)) for pos in makeShape() ] lengths = [ math.floor(length * (max_grain_length - 1) + 1) for length in makeShape() ] pans = makeShape() amps = [amp * dsp.rand(0, 10) for amp in makeShape()] num_grains = dsp.randint(500, 1000) grains = [] for i in range(num_grains): grain = dsp.cut(guitar, positions[i % len(positions)], lengths[i % len(lengths)]) grain = dsp.pan(grain, pans[i % len(pans)]) grain = dsp.amp(grain, amps[i % len(amps)]) grain = dsp.taper(grain, 20) grains += [grain] return ''.join(grains)
def chirp(): r = dsp.rand(3.6, 3.99) numpoints = dsp.randint(10, 30) freq = dsp.rand(200, 1000) slength = dsp.rand(0.05, 0.5) length = dsp.stf(slength) log = data.Logistic(r, size=numpoints) mod = dsp.breakpoint([0] + [dsp.rand() for r in range(numpoints / 3)] + [0], numpoints) mod = [p * log.get() for p in mod] modr = dsp.rand(1, 5) modf = 1.0 / slength wf = dsp.wavetable('sine2pi', 512) win = dsp.wavetable('sine', 512) pw = dsp.rand(0.5, 1) amp = dsp.rand(0.1, 0.3) out = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp) out = dsp.env(out, 'random') out = dsp.taper(out, dsp.mstf(10)) out = dsp.pan(out, dsp.rand()) out = dsp.pad(out, 0, dsp.stf(dsp.rand(0.1, 0.3))) return out
def makePulse(length, i): freqs = tune.fromdegrees([ dsp.randchoose([1,2,3,4,5,6,8]) for _ in range(dsp.randint(2,4)) ], octave=2, root=key) pulse = chord(length, freqs, dsp.rand(0.5, 0.75)) pulse = dsp.taper(pulse, 40) pulse = dsp.amp(pulse, dsp.rand(0.5, 1)) pulse = dsp.fill(pulse, length, silence=True) return pulse
def 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 makePulse(length, i): chord = tune.fromdegrees([ dsp.randchoose([1,4,5,8]) for _ in range(dsp.randint(2,4)) ], octave=2, root=key) pulse = rhodesChord(length, chord, dsp.rand(0.5, 0.75)) #pulse = dsp.mix([ pulse, kick ]) pulse = dsp.taper(pulse, 40) pulse = dsp.amp(pulse, dsp.rand(0.9, 1.5)) pulse = dsp.fill(pulse, length, silence=True) return pulse
def makeNote(length, note, degree=1): speed = tune.terry[tune.major[degree - 1]] speed = speed[0] / speed[1] note = dsp.transpose(note, speed) note = dsp.fill(note, length, silence=True) note = dsp.taper(note, dsp.mstf(10)) return note
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 make(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 = snare s = dsp.transpose(s, dsp.rand(0.9, 1.1)) s = dsp.fill(s, length, silence=True) return dsp.taper(s, 40)
def makeStab(length, i): freqs = tune.fromdegrees([ dsp.randchoose([1, 2, 3, 4, 5, 6, 8]) for _ in range(dsp.randint(2, 4)) ], octave=3, root=key) stab = chord(length, freqs, dsp.rand(0.25, 0.75)) stab = dsp.taper(stab, 40) stab = dsp.fill(stab, length, silence=True) return stab
def makePulse(length, i): freqs = tune.fromdegrees([ dsp.randchoose([1, 2, 3, 4, 5, 6, 8]) for _ in range(dsp.randint(2, 4)) ], octave=2, root=key) pulse = chord(length, freqs, dsp.rand(0.5, 0.75)) pulse = dsp.taper(pulse, 40) pulse = dsp.amp(pulse, dsp.rand(0.5, 1)) pulse = dsp.fill(pulse, length, silence=True) return pulse
def 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 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') pw = lpd.get(7, low=0.001, high=1, default=1) modr = dsp.rand(0, 0.005) modf = dsp.rand(0.01, 0.05) amp = lpd.get(8, low=0, high=2, default=0) length = dsp.mstf(lpd.get(6, low=40, high=1000, default=100)) divs = [1, 2, 3.0, 4] div = divs[lpd.geti(5, low=0, high=len(divs) - 1)] #div = dsp.randchoose(divs) length = int(length / div) wf = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for w in range(5) ] + [0], 512) wf = dsp.wavetable('sine2pi', 512) win = dsp.wavetable('sine', 512) mod = dsp.breakpoint([0] + [ dsp.rand(0, 1) for m in range(5) ] + [0], 512) layers = [] chord = [ dsp.randchoose([1, 3, 5, 6, 8, 16]) for c in range(dsp.randint(2, 4)) ] notes = tune.fromdegrees(chord, root='d', octave=dsp.randint(1, 2)) for freq in notes: a = amp * dsp.rand(0.1, 0.75) layer = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, a) layer = dsp.pan(layer, dsp.rand()) layers += [ layer ] out = dsp.mix(layers) out = dsp.taper(out) out = dsp.env(out, 'phasor') #out = dsp.pad(out, 0, length) #out = out * 4 return out
def makeGrains(): guitar = dsp.randchoose(guitars) guitar = dsp.transpose(guitar, dsp.randchoose([1, 2, 3, 4, 8])) max_grain_length = dsp.mstf(dsp.rand(10, 500)) positions = [ math.floor(pos * (dsp.flen(guitar) - max_grain_length)) for pos in makeShape() ] lengths = [ math.floor(length * (max_grain_length - 1) + 1) for length in makeShape() ] pans = makeShape() amps = [ amp * dsp.rand(0, 10) for amp in makeShape() ] num_grains = dsp.randint(500, 1000) grains = [] for i in range(num_grains): grain = dsp.cut(guitar, positions[ i % len(positions) ], lengths[ i % len(lengths) ]) grain = dsp.pan(grain, pans[ i % len(pans) ]) grain = dsp.amp(grain, amps[ i % len(amps) ]) grain = dsp.taper(grain, 20) grains += [ grain ] return ''.join(grains)
def makeSwells(cname, numswells, length, key='e', octave=1): swells = [] freqs = tune.chord(cname, key, octave) root = tune.ntf(key, octave) # Naive pitch wrapping for i, freq in enumerate(freqs): if freq > root * 2.5: freqs[i] = freq * 0.5 for _ in range(numswells): slength = dsp.randint((length / numswells) * 0.85, length / numswells) swell = [ keys.pulsar(freq, slength, drift=dsp.rand(0.001, 0.01), speed=dsp.rand(0.1, 0.5), amp=dsp.rand(0.2, 0.5)) for freq in freqs ] swell = dsp.mix(swell) swell = dsp.env(swell, 'hann') swell = dsp.taper(swell, 30) swells += [ swell ] swells = [ dsp.fill(swell, length / numswells, silence=True) for swell in swells ] return ''.join(swells)
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
for _ in range(nchords): layers = [] for _ in range(nlayers): layer = '' highs = dsp.breakpoint([ dsp.rand(60, 15000) for _ in range(npulses / 50) ], npulses) lows = [ dsp.rand(20, freq) for freq in highs ] amps = dsp.breakpoint([ dsp.rand(0.1, 0.3) for _ in range(npulses / 50) ], npulses) pans = dsp.breakpoint([ dsp.rand(0, 1) for _ in range(npulses / 10) ], npulses) lengths = [ dsp.mstf(l) for l in dsp.breakpoint([ dsp.rand(1, 30) for _ in range(npulses / 10) ], npulses) ] for high, low, amp, pan, length in zip(highs, lows, amps, pans, lengths): p = dsp.bln(length, low, high, wform=dsp.randchoose(['hann', 'sine2pi', 'tri'])) p = dsp.env(p, 'hann') p = dsp.taper(p, 20) p = dsp.amp(p, amp) p = dsp.pan(p, pan) layer += p layers += [ layer ] freqs = tune.fromdegrees([dsp.randint(1, 9) for _ in range(nlayers)], octave=1, root='a') for i, freq in enumerate(freqs): layers[i] = dsp.pine(layer, dsp.flen(layer) * 10, freq) section = dsp.fill(dsp.mix(layers), sectionlength) plen = dsp.randint(16, 32)
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')
def renv(snd, low=4, high=20, taper=True): e = [ dsp.rand() for _ in range(dsp.randint(low, high)) ] if taper: e = [0] + e + [0] return dsp.taper(dsp.benv(snd, e), 40)
from pippi import dsp from hcj import data numgrains = 1000 numsines = 100 length = dsp.mstf(100) dist = data.Logistic(3.99, 0.5, numsines).data dist = sorted(dist) lows = dsp.breakpoint([ dsp.rand(10, 100) for _ in range(100) ], numgrains) highs = dsp.breakpoint([ dsp.rand(100, 1000) for _ in range(100) ], numgrains) out = '' for lowfreq, highfreq in zip(lows, highs): layers = [] for freq in dist: r = highfreq - lowfreq layers += [ dsp.pan(dsp.tone(length, freq * r + lowfreq, amp=0.05), dsp.rand()) ] out += dsp.taper(dsp.env(dsp.mix(layers), 'hann'), dsp.mstf(10)) dsp.write(out, 'shifty')
def makeKick(length, i): return dsp.taper(dsp.fill(dsp.mix([ bigkick, kick ]), length, silence=True), 40)
pans = dsp.breakpoint([dsp.rand() for _ in range(55)], numgrains) lens = [ dsp.mstf(l * 80 + 20) for l in dsp.wavetable('line', numgrains / dsp.randint(50, 100)) ] seeds = [ s * 0.3 + 3.69 for s in dsp.wavetable('line', numgrains / dsp.randint(50, 100)) ] freqs = [ f * 90 + 10 for f in dsp.wavetable('line', numgrains / dsp.randint(50, 100)) ] for freq, seed, length, pan in zip(freqs, seeds, lens, pans): log = data.Logistic(seed, 0.5, 555) amp = dsp.rand(0.1, 0.75) grain = dsp.ctone(freq, length, log.data, amp) grain = dsp.env(grain, 'random') grain = dsp.taper(grain, dsp.mstf(5)) grain = dsp.pan(grain, pan) layer += grain layers += [layer] out = dsp.mix(layers) dsp.write(out, 'cdelsu')
[dsp.rand(0.1, 0.3) for _ in range(npulses / 50)], npulses) pans = dsp.breakpoint([dsp.rand(0, 1) for _ in range(npulses / 10)], npulses) lengths = [ dsp.mstf(l) for l in dsp.breakpoint( [dsp.rand(1, 30) for _ in range(npulses / 10)], npulses) ] for high, low, amp, pan, length in zip(highs, lows, amps, pans, lengths): p = dsp.bln(length, low, high, wform=dsp.randchoose(['hann', 'sine2pi', 'tri'])) p = dsp.env(p, 'hann') p = dsp.taper(p, 20) p = dsp.amp(p, amp) p = dsp.pan(p, pan) layer += p layers += [layer] freqs = tune.fromdegrees([dsp.randint(1, 9) for _ in range(nlayers)], octave=1, root='a') for i, freq in enumerate(freqs): layers[i] = dsp.pine(layer, dsp.flen(layer) * 10, freq) section = dsp.fill(dsp.mix(layers), sectionlength)
def make(length, i): return dsp.taper(dsp.fill(dsp.mix([bigkick, kick]), length, silence=True), 40)
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
for _ in range(numlayers): layer = '' for _ in range(numevents): slength = dsp.rand(0.1, 4) length = dsp.stf(slength) freq = (1.0 / slength) * dsp.rand(0.5, 10) amp = dsp.rand(0.1, 0.5) log = dsp.breakpoint( data.Logistic(dsp.rand(3.88, 3.99), 0.5, length / 10).data, length) mult = dsp.breakpoint( [0] + [dsp.rand(-1, 1) for _ in range(dsp.randint(50, 100))] + [0], length) wf = [m * l for m, l in zip(mult, log)] o = dsp.ctone(freq, length, wf, amp) o = dsp.env(o, 'random') o = dsp.pan(o, dsp.rand()) o = dsp.taper(o, dsp.mstf(20)) layer += o layers += [layer] out = dsp.mix(layers) dsp.write(out, 'lipsys')
numpoints = 7 wfs = [ dsp.breakpoint([dsp.rand(-1, 1) for p in range(numpoints)], 512) for _ in range(numsegs) ] win = dsp.wavetable('tri', 512) mods = [ dsp.breakpoint([dsp.rand(0, 1) for p in range(numpoints)], 512) for _ in range(numsegs) ] modfs = [dsp.rand(0.01, 0.1) for _ in range(numsegs)] modrs = [dsp.rand(0, 0.1) for _ in range(numsegs)] pws = [dsp.rand(0.01, 1) for _ in range(numsegs)] out = [] for wf, mod, modf, modr, pw in zip(wfs, mods, modfs, modrs, pws): layers = [] for freq in chord: layer = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, 0.1) layers += [layer] out += [dsp.mix(layers)] out = [dsp.taper(o, dsp.mstf(10)) for o in out] out = ''.join(out) dsp.write(out, 'truckidle')
layers = [] for layer in range(10): beats_steady = [beat for b in range(numbeats / 10)] beats_div = dsp.breakpoint([dsp.rand(1, 200) for b in range(10)], numbeats - len(beats_steady)) ramp = dsp.wavetable('line', len(beats_div)) beats_div = [beat + dsp.mstf(d * r) for d, r in zip(beats_div, ramp)] beats = beats_steady + beats_div freqs = dsp.wavetable(dsp.randchoose(['line', 'phasor', 'tri', 'hann']), len(beats)) freqs = [freq + (100 * f) for f in freqs] layer = '' for b, f in zip(beats, freqs): blip = dsp.tone(length=b, freq=f, amp=dsp.rand(0.01, 0.2)) blip = dsp.env(blip, 'phasor') blip = dsp.taper(blip, dsp.mstf(5)) blip = dsp.pan(blip, dsp.rand()) layer += blip layers += [layer] out = dsp.mix(layers) dsp.write(out, 'blipspray')
def play(ctl): param = ctl.get("param") lpd = ctl.get("midi").get("pc") lpd.setOffset(111) key = "g" # bd = dsp.read('/home/hecanjog/sounds/drums/Tinyrim2.wav').data # bd = dsp.read('/home/hecanjog/sounds/drums/Jngletam.wav').data # bd = dsp.read('/home/hecanjog/sounds/drums/78oh.wav').data # bd = dsp.amp(bd, 1) # bd = dsp.transpose(bd, dsp.rand(0.65, 0.72) / 1) # bd = dsp.transpose(bd, dsp.rand(0.3, 0.32) / 1) chord = tune.fromdegrees([1, 8], root="g", octave=dsp.randint(0, 2)) chord.reverse() chord = dsp.rotate(chord, lpd.geti(4, low=0, high=len(chord) - 1)) # chord = dsp.randshuffle(chord) reps = param.get("reps", default=16) rep = param.get("rep", default=0) beat = dsp.bpm2frames(130) / 4 beat = dsp.mstf(4100) / 32 # length = beat out = "" for n in range(4): freq = chord[int(rep) % len(chord)] if dsp.rand() > 0.5: freq *= 2 ** dsp.randint(0, lpd.geti(7, low=0, high=8, default=0)) pw = lpd.get(8, low=0.1, high=1, default=1) # length = dsp.mstf(lpd.get(2, low=50, high=2500, default=500) * dsp.rand(0.5, 2)) length = dsp.mstf(lpd.get(14, low=50, high=5000, default=500)) wf = dsp.wavetable("tri", 512) wf = dsp.wavetable("impulse", 512) wf = dsp.wavetable("sine2pi", 512) wf = dsp.breakpoint([0] + [dsp.rand(-1, 1) for w in range(lpd.geti(15, low=4, high=200, default=4))] + [0], 512) win = dsp.wavetable("sine", 512) mod = [dsp.rand(0, 1) for m in range(512)] modr = dsp.rand(0.01, 0.02) modr = lpd.get(16, low=0.01, high=1, default=1) modf = dsp.rand(0.5, 2) amp = lpd.get(6, low=0, high=2, default=0) amp = dsp.rand(0, 2) o = dsp.pulsar(freq, length, pw, wf, win, mod, modr, modf, amp) o = dsp.env(o, "random") o = dsp.taper(o, dsp.mstf(10)) o = dsp.pan(o, dsp.rand()) rep = rep + 1 out += o # out = dsp.mix([ dsp.fill(bd, dsp.flen(out), silence=True), out ]) param.set("rep", (rep + 1) % reps) return out