def fade(snd, time=dsp.mstf(1)): first = dsp.cut(snd, 0, time) middle = dsp.cut(snd, time, dsp.flen(snd) - (time * 2)) last = dsp.cut(snd, dsp.flen(middle) + time, time) snd = dsp.env(first, 'line') + middle + dsp.env(last, 'phasor') return snd
def ding(tone, tlength=88200, nlength=1000): 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 numtones = tlength / nlength numtones = 1 if numtones < 1 else numtones freqs = [ note / tune.ntf('g', 4) for note in sequence('g') ] tones = [ dsp.transpose(tone, freq) for freq in freqs ] #tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength + dsp.randint(0, 500)) for i in range(numtones) ] tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength) for i in range(numtones) ] #tones = [ dsp.drift(tone, 0.03) for tone in tones ] curve = dsp.breakpoint([0] + [ dsp.rand(0, 0.01) for i in range(3) ], len(tones)) tones = [ dsp.drift(tone, curve[index % len(curve)]) for index, tone in enumerate(tones) ] tones = [ fade(tone) for tone in tones ] return dsp.amp(''.join(tones), 0.5)
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 ding(tone, tlength=88200, nlength=1000): 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 numtones = tlength / nlength numtones = 1 if numtones < 1 else numtones freqs = [note / tune.ntf('g', 4) for note in sequence('g')] tones = [dsp.transpose(tone, freq) for freq in freqs] #tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength + dsp.randint(0, 500)) for i in range(numtones) ] tones = [ dsp.cut(tones[i % len(tones)], dsp.mstf(dsp.rand(0, 100)), nlength) for i in range(numtones) ] #tones = [ dsp.drift(tone, 0.03) for tone in tones ] curve = dsp.breakpoint([0] + [dsp.rand(0, 0.01) for i in range(3)], len(tones)) tones = [ dsp.drift(tone, curve[index % len(curve)]) for index, tone in enumerate(tones) ] tones = [fade(tone) for tone in tones] return dsp.amp(''.join(tones), 0.5)
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 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 makeGlitch(length, i): g = dsp.cut(long_chord, dsp.randint(0, dsp.flen(long_chord) - length), length) g = dsp.alias(g) g = dsp.fill(g, length) return g
def 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 make_pulse(snd): snd_len = dsp.flen(snd) blip = dsp.cut(snd, 0, dsp.mstf(10)) blip = dsp.env(blip, 'sine') blip = dsp.pad(blip, 0, snd_len - dsp.flen(blip)) return blip
def fracture(snd): numpoints = dsp.randint(3, 20) poscurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) poscurve = [ p * (dsp.flen(snd) - dsp.mstf(210)) for p in poscurve ] lencurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) lencurve = [ l * dsp.mstf(200) + dsp.mstf(10) for l in lencurve ] pancurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) prepadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) prepadcurve = [ int(p * dsp.mstf(20)) for p in prepadcurve ] postpadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) postpadcurve = [ int(p * dsp.mstf(20)) for p in postpadcurve ] speeds = [1.0, 2.0, 0.5, 0.75] grains = [ dsp.cut(snd, poscurve[i], lencurve[i]) for i in range(numpoints) ] grains = [ dsp.pan(grains[i], pancurve[i]) for i in range(numpoints) ] grains = [ dsp.env(grain, 'gauss', True) for grain in grains ] grains = [ dsp.transpose(grain, dsp.randchoose(speeds)) for grain in grains ] grains = [ dsp.pad(grains[i], prepadcurve[i], postpadcurve[i]) for i in range(numpoints) ] for i in range(numpoints): if dsp.randint(0, 3) == 0: grains[i] = slurp(grains[i]) etypes = ['line', 'phasor', 'tri', 'sine', 'gauss'] snd = dsp.env(''.join(grains), dsp.randchoose(etypes)) snd = dsp.pad(snd, 0, dsp.mstf(dsp.rand(100, 400))) return snd
def 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 fracture(snd): numpoints = dsp.randint(3, 20) poscurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) poscurve = [p * (dsp.flen(snd) - dsp.mstf(210)) for p in poscurve] lencurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) lencurve = [l * dsp.mstf(200) + dsp.mstf(10) for l in lencurve] pancurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) prepadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) prepadcurve = [int(p * dsp.mstf(20)) for p in prepadcurve] postpadcurve = dsp.breakpoint([0] + [dsp.rand() for i in range(4)] + [0], numpoints) postpadcurve = [int(p * dsp.mstf(20)) for p in postpadcurve] speeds = [1.0, 2.0, 0.5, 0.75] grains = [dsp.cut(snd, poscurve[i], lencurve[i]) for i in range(numpoints)] grains = [dsp.pan(grains[i], pancurve[i]) for i in range(numpoints)] grains = [dsp.env(grain, 'gauss', True) for grain in grains] grains = [dsp.transpose(grain, dsp.randchoose(speeds)) for grain in grains] grains = [ dsp.pad(grains[i], prepadcurve[i], postpadcurve[i]) for i in range(numpoints) ] for i in range(numpoints): if dsp.randint(0, 3) == 0: grains[i] = slurp(grains[i]) etypes = ['line', 'phasor', 'tri', 'sine', 'gauss'] snd = dsp.env(''.join(grains), dsp.randchoose(etypes)) snd = dsp.pad(snd, 0, dsp.mstf(dsp.rand(100, 400))) return snd
def sing(lyrics, freqs, speed=0, voice='english'): """ sing it mad slow in chords """ out = speak(lyrics, speed, voice) layers = [] for freq in freqs: layer = dsp.transpose(out, 0.25) layer = dsp.pine(layer, dsp.flen(layer) * 4, freq) slop = int(dsp.flen(layer) * 0.12) layer = dsp.cut(layer, slop, dsp.flen(layer) - (slop * 2)) layer = dsp.transpose(layer, 4) layer = dsp.pan(layer, dsp.rand()) layer = dsp.amp(layer, 0.5) layers += [ layer ] out = dsp.mix(layers) 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)
elapsed = 0 while elapsed < length: # pick a fragment g = dsp.randchoose(guitars) # transpose to A g = dsp.transpose(g, 1.125) # rand octave or 5th transpose g = dsp.transpose(g, dsp.randchoose([1, 1.5, 2])) # slice fragment btwn 60ms and 1/2 frag length fraglen = dsp.mstf(dsp.rand(60, dsp.flen(g) / 2)) pos = dsp.randint(0, dsp.flen(g) - fraglen) g = dsp.cut(g, pos, fraglen) # attenuate g = dsp.amp(g, dsp.rand(0.1, 0.5)) # randomly pan g = dsp.pan(g, dsp.rand()) # add frag length to elapsed time elapsed += dsp.flen(g) # add fragment to frag list frags += [ g ] # concat all frags layer = ''.join(frags)
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')
tlen = sum(seg) layers = [] def mixdrift(snd): if dsp.randint(0, 4) == 0: dsnd = dsp.drift(snd, dsp.rand(0.001, 0.04)) snd = dsp.mix([ snd, dsp.amp(dsnd, 0.5) ]) return snd if canPlay('folds', bigoldsection): if dsp.randint(0,1) == 0 or canPlay('jam', bigoldsection): # Guitar folds segsounds = [] for length in seg: sounds = [ dsp.cut(layer, dsp.randint(0, dsp.flen(layer) - length), length) for s in range(6) ] sounds = dsp.mix(sounds) segsounds += [ sounds ] segsounds = ''.join(segsounds) segsounds = mixdrift(segsounds) foldsPlay += 1 layers += [ segsounds ] if canPlay('blips', bigoldsection): if dsp.randint(0,1) == 0 or canPlay('jam', bigoldsection): # Blips blips = []
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(args): length = dsp.stf(30) 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, 30) layers = [] for note in notes: tones = [] freq = tune.ntf(note, octave, ratios) for i in range(30): angles = dsp.breakpoint([freq * dsp.randchoose(harm) for f in range(dsp.randint(3, 50))], dsp.randint(350, 500)) alen = int(length / len(angles)) * 2 angles = [ dsp.env(dsp.tone(alen, a, 'random'), 'sine') for a in angles ] # Each overtone blip should overlap by about 50% with its neighbor... lowangles = ''.join([ angle for i, angle in enumerate(angles) if i % 2 == 0 ]) highangles = [ angle for i, angle in enumerate(angles) if i % 2 != 0 ] highangles[0] = dsp.cut(highangles[0], dsp.flen(highangles[0]) / 2, dsp.flen(highangles[0]) / 2) highangles = ''.join(highangles) tones += [ dsp.benv(dsp.amp(dsp.mix([lowangles, highangles]), 0.9), [dsp.rand(0.1, 0.9) for i in range(dsp.randint(5, 30))]) ] tones = dsp.mix(tones) #tonic = dsp.env(dsp.amp(dsp.tone(int(length * 0.6), freq, 'sine2pi'), 0.1), 'flat') #layers += [ dsp.mix([tones, tonic], False) ] layers += [ tones ] out = dsp.mix(layers) return dsp.amp(out, volume)
def mixdrift(snd): if dsp.randint(0, 4) == 0: dsnd = dsp.drift(snd, dsp.rand(0.001, 0.04)) snd = dsp.mix([snd, dsp.amp(dsnd, 0.5)]) return snd if canPlay('folds', bigoldsection): if dsp.randint(0, 1) == 0 or canPlay('jam', bigoldsection): # Guitar folds segsounds = [] for length in seg: sounds = [ dsp.cut(layer, dsp.randint(0, dsp.flen(layer) - length), length) for s in range(6) ] sounds = dsp.mix(sounds) segsounds += [sounds] segsounds = ''.join(segsounds) segsounds = mixdrift(segsounds) foldsPlay += 1 layers += [segsounds] if canPlay('blips', bigoldsection): if dsp.randint(0, 1) == 0 or canPlay('jam', bigoldsection): # Blips blips = []
def play(params): length = params.get('length', dsp.stf(20)) volume = params.get('volume', 0.3) octave = params.get('octave', 6) note = params.get('note', 'c') quality = params.get('quality', tune.major) multiple = params.get('multiple', 1) width = params.get('width', 0) waveform = params.get('waveform', 'vary') chirp = params.get('chirp', False) harmonics = params.get('harmonics', [1, 2]) scale = params.get('scale', [1, 4, 6, 5, 8]) wavetypes = params.get('wavetypes', ['sine', 'phasor', 'line', 'saw']) ratios = params.get('ratios', tune.terry) glitch = params.get('glitch', False) def chirp(s): length = dsp.flen(s) #chirps = [ dsp.chirp(dsp.randint(10, 10000), 60, 5000, dsp.randint(1,100)) for c in range(100) ] chirps = [ dsp.chirp( numcycles=dsp.randint(50, 1000), lfreq=dsp.rand(9000, 12000), hfreq=dsp.rand(14000, 20000), length=441 + (i * 41), etype=dsp.randchoose(['gauss', 'sine', 'line', 'phasor']), wform=dsp.randchoose(['sine', 'tri', 'phasor', 'line'])) for i in range(100) ] chirps = [ dsp.pan(c, dsp.rand()) for c in chirps ] chirps = ''.join(chirps) return dsp.fill(chirps, length) tones = [] multiple *= 1.0 freqs = tune.fromdegrees(dsp.randshuffle(scale), octave, note[0]) for i in range(dsp.randint(2,4)): #freq = tune.step(i, note, octave, dsp.randshuffle(scale), quality, ratios) freq = freqs[i % len(freqs)] snds = [ dsp.tone(length, freq * h, waveform) for h in harmonics ] for snd in snds: snd = dsp.vsplit(snd, dsp.mstf(10 * multiple), dsp.mstf(100 * multiple)) if width != 0: for ii, s in enumerate(snd): if width > dsp.mstf(5): owidth = int(width * dsp.rand(0.5, 2.0)) else: owidth = width olen = dsp.flen(s) s = dsp.cut(s, 0, owidth) s = dsp.pad(s, 0, olen - dsp.flen(s)) snd[ii] = s snd = [ dsp.env(s, dsp.randchoose(wavetypes)) for s in snd ] snd = [ dsp.pan(s, dsp.rand()) for s in snd ] snd = [ dsp.amp(s, dsp.rand()) for s in snd ] if chirp == True: snd = [ chirp(s) for s in snd ] snd = ''.join(snd) tones += [ snd ] out = dsp.mix(tones) out = dsp.pan(out, dsp.rand()) return dsp.amp(out, volume)
from pippi import dsp snd = dsp.read('sounds/seneca3bars.wav').data numgrains = 40 lens = [1 for _ in range(numgrains / 2)] lens = lens + dsp.wavetable('hann', numgrains)[len(lens):] lens = [dsp.mstf(l * 40 + 30) for l in lens] out = '' lpos = 0 rpos = dsp.mstf(100) for i in range(numgrains): l = dsp.cut(snd, lpos, lens[i]) r = dsp.cut(snd, rpos, lens[i]) lpos += dsp.mstf(dsp.rand(1, 10)) rpos += dsp.mstf(dsp.rand(1, 10)) out += dsp.pan(l, 0) out += dsp.pan(r, 1) dsp.write(out, 'alter')
elapsed = 0 while elapsed < length: # pick a fragment g = dsp.randchoose(guitars) # transpose to A g = dsp.transpose(g, 1.125) # rand octave or 5th transpose g = dsp.transpose(g, dsp.randchoose([1, 1.5, 2])) # slice fragment btwn 60ms and 1/2 frag length fraglen = dsp.mstf(dsp.rand(60, dsp.flen(g) / 2)) pos = dsp.randint(0, dsp.flen(g) - fraglen) g = dsp.cut(g, pos, fraglen) # attenuate g = dsp.amp(g, dsp.rand(0.1, 0.5)) # randomly pan g = dsp.pan(g, dsp.rand()) # add frag length to elapsed time elapsed += dsp.flen(g) # add fragment to frag list frags += [g] # concat all frags layer = ''.join(frags)
def makeHat(length, i, amp): h = dsp.cut(hat, 0, dsp.randint(dsp.mstf(10), dsp.mstf(60))) h = dsp.env(h, 'phasor') h = dsp.amp(h, dsp.rand(0.5, 0.9)) h = dsp.fill(h, length, silence=True) return h
from pippi import dsp from pippi import tune import audioop thirty = dsp.read('thirty.wav').data wesley = dsp.read('wesley.wav').data snds = [thirty, wesley] ## 01 out = '' t = thirty * 30 t = dsp.pan(t, 0) tt = dsp.cut(thirty, 0, dsp.flen(thirty) - dsp.mstf(30)) * 30 tt = dsp.pan(tt, 1) out = dsp.mix([ t, tt ]) dsp.write(out, 'wesley_thirty_01') ## 02 out = '' t = dsp.split(thirty, dsp.mstf(40)) t = [ dsp.env(tt, 'sine') for tt in t ] t = [ tt * 4 for tt in t ] out = ''.join(t) dsp.write(out, 'wesley_thirty_02') ## 03 out = ''
def play(params): volume = params.get('volume', dsp.rand(70.0, 100.0)) / 100.0 notes = params.get('note', [ dsp.randchoose(['c', 'f', 'e', 'a', 'd']) for i in range(2) ]) octave = params.get('octave', dsp.randint(1, 5)) root = params.get('root', 27.5) bpm = params.get('bpm', 75.0) if dsp.randint(0, 1) == 0: length = params.get('length', dsp.mstf(dsp.rand(10, 2000))) else: length = params.get('length', int(dsp.randint(1, 4) * dsp.bpm2frames(bpm) * 0.25)) env = params.get('envelope', 'random') env = params.get('envelope', 'tri') mod = params.get('mod', 'random') modFreq = params.get('modfreq', dsp.rand(1.0, 1.5) / dsp.fts(length)) modRange = params.get('speed', 0.01) modRange = dsp.rand(0, modRange) pulsewidth = params.get('pulsewidth', dsp.rand(0.01, 0.8)) window = params.get('window', 'gauss') #waveform = params.get('waveform', 'random') waveform = params.get('waveform', 'tri') glitch = params.get('glitch', True) pulsewidth = 1.0 freqs = [ tune.ntf(note, octave) for note in notes ] tune.a0 = float(root) mod = dsp.wavetable(mod, 512) window = dsp.wavetable(window, 512) waveform = dsp.wavetable(waveform, 512) layers = [] for freq in freqs: layers += [ dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume) ] out = dsp.mix(layers) try: out = dsp.env(out, env) except TypeError: out = dsp.env(out, 'sine') if glitch: bitlen = dsp.randint(dsp.mstf(10), dsp.mstf(500)) bit = dsp.cut(out, dsp.randint(0, len(out) - bitlen), bitlen) out = dsp.vsplit(out, dsp.mstf(10), dsp.mstf(500)) out.insert(dsp.randint(0, len(out) - 2), bit) out = ''.join(out) out = dsp.pan(out, dsp.rand()) return out