def test_sub_soundbuffers(self):
snd = dsp.buffer([1, 2, 3])
self.assertEqual(len(snd), 3)
self.assertEqual(snd - 2, dsp.buffer([-1, 0, 1]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
self.assertEqual(snd - dsp.buffer([1, 3, 5]), dsp.buffer([0, -1, -2]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
self.assertEqual(dsp.buffer([1, 3, 5]) - snd, dsp.buffer([0, 1, 2]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
snd -= 2
self.assertEqual(snd, dsp.buffer([-1, 0, 1]))
def test_add_soundbuffers(self):
snd = dsp.buffer([1,2,3])
self.assertEqual(len(snd), 3)
self.assertEqual(snd + 2, dsp.buffer([3,4,5]))
self.assertEqual(snd, dsp.buffer([1,2,3]))
self.assertEqual(snd + dsp.buffer([1,3,5]), dsp.buffer([1,2,3,1,3,5]))
self.assertEqual(snd, dsp.buffer([1,2,3]))
self.assertEqual(dsp.buffer([1,3,5]) + snd, dsp.buffer([1,3,5,1,2,3]))
self.assertEqual(snd, dsp.buffer([1,2,3]))
snd += 2
self.assertEqual(snd, dsp.buffer([3,4,5]))
def test_mul_soundbuffers(self):
snd = dsp.buffer([1, 2, 3])
self.assertEqual(len(snd), 3)
self.assertEqual(snd * 2, dsp.buffer([2, 4, 6]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
self.assertEqual(snd * dsp.buffer([1, 3, 5]), dsp.buffer([1, 6, 15]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
self.assertEqual(dsp.buffer([1, 3, 5]) * snd, dsp.buffer([1, 6, 15]))
self.assertEqual(snd, dsp.buffer([1, 2, 3]))
snd *= 2
self.assertEqual(snd, dsp.buffer([2, 4, 6]))
def rank_score(r):
params = rToParams(r)
out = Synth(params)
out = dsp.buffer(length=1, channels=1)
s = Synth(params)
out.dub(s.buff, params.start)
a = memToAud(out)
try:
im = audToImage(a, 128)
except:
return [], False
z = librosa.util.normalize(im)
z = (((z - z.min()) / (z.max() - z.min())) * 253).astype(np.uint8)
zi = Image.fromarray(z)
z = t(zi)
images = z.reshape([1, 1, 128, 128])
dimg = images.to(device)
outputs = cnn(dimg)
_, predicted = torch.max(outputs, 1)
o = outputs.cpu().detach().numpy()[0]
o_norm = o - min(o)
o_norm = o_norm / sum(o_norm)
score_dict = dict(zip(classes, o_norm))
#ranks based on score
ranks = 1 + len(classes_ranked) - ss.rankdata(o_norm)
rank_dict = dict(zip(classes_ranked, ranks))
df = pd.concat([
pd.DataFrame.from_dict([rank_dict]),
pd.DataFrame.from_dict([score_dict]),
paramToDF([params])
],
axis=1)
return df.iloc[0], True
def make_melody(self, sequence, name):
out = dsp.buffer()
pos = 0
beat = 0.05
pause = 0.5
for keys in sequence:
notes = self.keys_to_notes(keys=keys)
print("Playing the following notes: {}".format(notes))
frequencies = [
self.get_frequency(key=tone[:-1], octave=int(tone[-1]))
for tone in notes
]
print("Corresponding to the frequencies: {}".format(frequencies))
speeds = self.get_speeds(frequencies)
for speed in speeds:
# Create a pitch-shifted copy of the original guitar
tone = self.base_tone.speed(speed)
# Dub it into the output buffer at the current position in seconds
out.dub(tone, pos)
# Now move the write position forward <beat> seconds
pos += beat
pos += pause
# Save this output buffer
out.write('../output/harmonic/renders/melody_{}.wav'.format(name))
pass
def rush(snd):
out = dsp.buffer()
length = random.randint(4410, 44100 * 3)
numbeats = random.randint(16, 64)
reverse = random.choice([True, False])
wintype = random.choice(
['sine', 'tri', 'kaiser', 'hann', 'blackman', None])
wavetable = None if wintype is not None else [
random.random() for _ in range(random.randint(3, 10))
]
pattern = rhythm.curve(numbeats=numbeats,
wintype=wintype,
length=length,
reverse=reverse,
wavetable=wavetable)
minspeed = random.triangular(0.15, 2)
pan = random.random()
for onset in pattern:
hit = snd * random.triangular(0, 0.5)
hit = hit.speed(random.triangular(minspeed, minspeed + 0.08))
hit = hit.pan(pan)
out.dub(hit, onset)
return out
def dub2(songid1, songid2, dist_value, posi, var):
out = dsp.buffer()
dubhead = 0
#filename = Song.query.filter_by(id=songid1).first().filename
#audio = dsp.read(os.path.join(app.instance_path, filename))
labels2 = [i.note for i in Beat.query.filter_by(song_id=songid1)]
ar = dist(dist_value, posi)
for e, i in enumerate(labels2):
while dubhead < 60:
rstart = [s.start for s in Beat.query.filter_by(note=i)]
rend = [s.end for s in Beat.query.filter_by(note=i)]
source = [s.song_id for s in Beat.query.filter_by(note=i)]
rpool = [(rstart[i], rend[i], source[i])
for i in range(0, len(rstart))]
sl = random.choice(rpool)
bl = int(sl[1] - sl[0])
l = (sl[1] + (bl * np.random.choice(16, p=ar)))
filename = Song.query.filter_by(id=sl[2]).first().filename
audio = dsp.read(os.path.join(app.instance_path, filename))
a = audio[sl[0]:l]
stime = librosa.samples_to_time(len(a), sr=44100)
#var = 0.5
a = a.taper((stime / 2) * var)
out.dub(a, dubhead)
dubhead += stime - ((stime / 2) * var)
return out
def makelayer(speeds):
snd = dsp.read('harps/harp_006.wav')
length = int(60 * 1000 * sr) * 2
out = dsp.buffer(length=1)
speed = random.choice(speeds) * random.choice([0.125, 0.25, 0.5, 1])
s = snd.speed(speed)
panpos = random.random()
pulselength = int(random.triangular(1, 80) * sr)
numpulses = length // pulselength
tablesize = numpulses // 100
ptable = interpolation.linear([ random.random() for _ in range(tablesize) ], numpulses)
ftable = wavetables.window('line', numpulses)
print('rendering speed: %s pan: %s len: %s num: %s' % (speed, panpos, pulselength, numpulses))
osc = oscs.Osc(wavetable='tri')
for i in range(numpulses-1):
start = ptable[i] * len(s) - pulselength
bit1 = s.cut(start if start > 0 else 0, pulselength)
#bit2 = osc.play(length=pulselength, freq=100 * (ftable[i] + 1), amp=0.5)
#bit1 = bit1 * bit2
bit1 = bit1.env('sine')
out.dub(bit1.pan(panpos) * 0.5, i * (pulselength//2))
print('done speed: %s pan: %s len: %s num: %s' % (speed, panpos, pulselength, numpulses))
return out
def offline_render(self):
print('BEGIN RENDER')
self.rendering = True
notes = []
maxlength = 0
for notelane in self.lanes.notes:
for noteindex, note in enumerate(notelane.notes):
notes += [(note.onset, note.length, note.freq)]
maxlength = max(maxlength, note.onset + note.length)
out = dsp.buffer(length=maxlength)
# load instrument
manager = mp.Manager()
bus = manager.Namespace()
bus.stop_all = manager.Event() # voices
bus.shutdown_flag = manager.Event() # render & analysis processes
bus.stop_listening = manager.Event() # midi listeners
instrument = orc.load_instrument('default', 'orc/pianotone.py', bus)
for note in notes:
params = {'length': float(note[1]), 'freq': float(note[2])}
ctx = instrument.create_ctx(params)
generator = instrument.renderer.play(ctx)
for snd in generator:
out.dub(snd, float(note[0]))
# render
out.write('pianoroll_render.wav')
self.sndfile = SoundLoader.load('pianoroll_render.wav')
if self.sndfile:
self.sndfile.play()
self.playhead_clock = Clock.schedule_interval(self.update_playhead, 0.01)
self.rendering = False
print('DONE RENDERING')
def test_create_bar(self):
length = 1
out = dsp.buffer(length=length)
params = [(0.21, 1, 0), (0.3, 0.9, 0.5), (0.22, 0.8, 1)]
for beat, inc, pan in params:
pos = 0
stiffness = 280
while pos < length:
duration = dsp.rand(1, 4)
decay = dsp.rand(0.1, 10)
velocity = dsp.rand(500, 2000)
barpos = dsp.rand(0.2, 0.8)
width = dsp.rand(0.1, 0.8)
stiffness = max(1, stiffness)
note = Bar(decay=decay, stiffness=stiffness, velocity=velocity, barpos=barpos, width=width).play(duration).env('hannout').pan(pan)
out.dub(note, pos)
pos += beat
stiffness -= inc
out = fx.norm(out, 1)
out.write('tests/renders/osc_bar.wav')
def mix(ingredients, length):
out = dsp.buffer(length=length)
for ingredient in ingredients:
pos = dsp.rand(0, length - ingredient.dur)
out.dub(ingredient, pos)
out = fx.norm(out, 0.5)
return out
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 makesnares():
out = dsp.buffer(length=1)
beat = length
numbeats = 16 * 4 * lenmult
pat = rhythm.topattern('..x...x...x...xx..x...x...x....x')
onsets = rhythm.onsets(pat, beat, numbeats)
for i, pos in enumerate(onsets):
if random.random() > 0.75:
s = dsp.buffer(length=1)
p = rhythm.curve(numbeats=random.randint(4, 10), wintype='random', length=beat*random.randint(2,3))
for o in p:
s.dub(snare.speed(random.triangular(0.9,1.1)) * random.random(), o)
out.dub(s, pos)
out.dub(snare, pos)
return out
def make(drum, pat, lengths):
events = [ [pat[i], lengths[i]] for i in range(len(pat)) ]
if len(events) > 0:
out = dsp.join([ drum(event[0] * 0.3, event[1]) for event in events ])
else:
print(lengths, pat)
out = dsp.buffer(length=sum(lengths))
return out
def test_dub_overflow(self):
sound = dsp.read('tests/sounds/guitar1s.wav')
out = dsp.buffer()
numdubs = 3
maxpos = 4
for _ in range(numdubs):
pos = random.triangular(0, maxpos)
out.dub(sound, pos)
self.assertTrue(len(out) <= (maxpos * out.samplerate) + len(sound))
def makekicks():
out = dsp.buffer(length=1)
beat = length
numbeats = 16 * 4 * lenmult
pat = rhythm.topattern('x...')
onsets = rhythm.onsets(pat, beat, numbeats)
for i, pos in enumerate(onsets):
out.dub(kick.speed(random.triangular(0.8,1)) * 1.4, pos)
return out
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 test_create_mono_buffer_from_wavetable(self):
wt = dsp.wt('sine', wtsize=4096)
self.assertTrue(len(wt) == 4096)
snd = dsp.buffer(wt)
self.assertTrue(len(snd) == 4096)
self.assertTrue(snd[100][0] != 0)
snd = SoundBuffer(wt)
self.assertTrue(len(snd) == 4096)
self.assertTrue(snd[100][0] != 0)
def test_create_tukey(self):
length = 10
shape = dsp.win(shapes.win('sine', length=3), 0, 0.5)
chord = tune.chord('i9', octave=2)
out = dsp.buffer(length=length)
for freq in chord:
freq = dsp.wt('sinc', freq, freq*4)
l = Tukey(freq=freq, shape=shape).play(length)
l = l.pan(dsp.rand())
out.dub(l)
out = fx.norm(out, 0.8)
out.write('tests/renders/osc_tukey.wav')
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)
def makehats():
out = dsp.buffer(length=1)
beat = length // 2
numbeats = 16 * 8 * lenmult
pat = rhythm.topattern('x xxx xx')
onsets = rhythm.onsets(pat, beat, numbeats)
onsets = rhythm.swing(onsets, 0.5, beat)
for i, pos in enumerate(onsets):
out.dub(hat.speed(random.triangular(1.5, 2)) * random.triangular(0.35, 0.45), pos)
return out
def render(ttfeatures, ttfit, db, freq=1.0):
out = dsp.buffer(length=512 * ttfeatures.shape[0] / sr, samplerate=sr)
skip = sr // int((1 / freq) * 512)
steps = ttfit.shape[0] // skip
for i in range(steps):
j = i * skip
index = int(ttfit[j])
s = get_samples(db["filenames"][index])
t = j * 512 / sr
# print(t,index)
out.dub(s, t)
return out
def arp(i):
cluster = dsp.buffer()
length = random.randint(44100, 44100 + 22050)
numnotes = random.randint(3, 12)
onsets = rhythm.curve(numnotes, dsp.RND, length)
chord = chords[i % len(chords)]
freqs = tune.chord(chord, octave=random.randint(1, 3))
for i, onset in enumerate(onsets):
freq = freqs[i % len(freqs)]
note = samp.play(freq)
note = note.pan(random.random())
note *= random.triangular(0, 0.125)
cluster.dub(note, onset / cluster.samplerate)
return cluster
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 dub(df1, df2, audio):
out = dsp.buffer()
dubhead = 0
while dubhead < 210
for e, i in enumerate(df2.labels[:1200]):
rpool = list(df1['startstop'][df1['labels'] == i])
try:
sl = random.choice(rpool)
except:
print(i)
if audio[sl[0]:sl[1]+int((sl[1]-sl[0])/2)]:
a = audio[sl[0]:sl[1]+int((sl[1]-sl[0])/2)]
else:
a = audio[sl[0]:sl[1]]
out.dub(a, dubhead)
dubhead += librosa.samples_to_time((sl[1]-sl[0]), sr=44100)
print("done dubbing number " + str(e) + " of " + str(len(df2.labels)))
return out
def makesynths():
out = dsp.buffer(length=1)
beat = length // 2
numbeats = 16 * 8 * lenmult
pat = rhythm.topattern('x..x....')
onsets = rhythm.onsets(pat, beat, numbeats)
for i, pos in enumerate(onsets):
chord = chords[i % len(chords)]
freqs = tune.chord(chord)
for freq in freqs:
lfo = random.random() * i * 0.5
note = makenote(random.randint(length // 4, length * 3), freq * 0.25 * 2**random.randint(0, 4), lfo, factor=random.randint(1, 10))
note = note.env('phasor')
note = note.pan(random.random())
out.dub(note * 0.65, pos)
return out
def makearps():
out = dsp.buffer(length=1)
beat = length // 2
numbeats = 16 * 8 * lenmult
pat = rhythm.topattern('xxxxxxxx')
onsets = rhythm.onsets(pat, beat, numbeats)
osc = oscs.Osc('tri')
for i, pos in enumerate(onsets):
chord = chords[i//4 % len(chords)]
freqs = tune.chord(chord)
freq = freqs[i % len(freqs)]
amp = random.triangular(0.1, 0.2)
pw = random.triangular(0.15, 1)
note = osc.play(beat, freq * 2, amp * 0.25, pw)
note = note.env('phasor')
out.dub(note, pos)
return out
def makeblips():
out = dsp.buffer(length=1)
beat = length // 2
numbeats = 16 * 8 * lenmult
pat = rhythm.topattern('x..x..x.')
onsets = rhythm.onsets(pat, beat, numbeats)
for i, pos in enumerate(onsets):
chord = chords[i*2 % len(chords)]
freqs = tune.chord(chord)
lfo = random.random() * 2
freq = freqs[0] * 0.5
if i % 8 == 0:
freq *= 2
note = makenote(length, freq, lfo, factor=random.randint(1, 10))
note = note.env('phasor')
out.dub(note * 2, pos)
return out
def hihat(amp, length):
if amp == 0:
return dsp.buffer(length=length)
def hat(length):
lowf = dsp.rand(6000, 11000)
highf = dsp.rand(11000, 17000)
if dsp.rand() > 0.5:
length *= 0.05
out = bln(length, lowf, highf)
out = out.env(dsp.choice(['rsaw', 'phasor', 'hannout']))
return out
if dsp.rand() > 0.5:
out = dsp.join([ hat(length / 2), hat(length / 2) ])
else:
out = hat(length)
return out
def test_fft_transform(self):
snd = dsp.read('tests/sounds/guitar1s.wav')
snd2 = dsp.read('tests/sounds/LittleTikes-B1.wav').cut(0, 1)
mod = dsp.buffer(dsp.win('sine', wtsize=len(snd))).remix(1).remix(2)
# Transform
real1, imag1 = fft.transform(snd)
real2, imag2 = fft.transform(snd2)
# Do stuff
imag = real1 * real2
real = imag1 * imag2
mag, arg = fft.to_polar(real, imag)
#mag = fx.lpf(mag, 100)
real, imag = fft.to_xy(mag, arg)
# Inverse Transform
out = fft.itransform(real, imag)
out = fx.norm(out, 1)
out.write('tests/renders/fft_transform.wav')
def test_onsets(self):
snd = dsp.read('tests/sounds/rain.wav')
onsets = mir.onsets(snd, 'specflux')
self.assertEqual(len(onsets), 7)
onsets = mir.onsets(snd, 'specflux', seconds=False)
print(onsets)
self.assertEqual(len(onsets), 7)
segments = mir.segments(snd, 'specflux')
self.assertEqual(len(segments), 7)
out = dsp.buffer(length=7)
pos = 0
count = 1
for segment in segments:
segment = fx.norm(segment.env('pluckout').taper(0.05), 1)
segment.write('tests/renders/mir_segment%02d.wav' % count)
out.dub(segment, pos)
pos += 1
count += 1
out.write('tests/renders/mir_segments.wav')
pluckout
) * 0.5 # Also multiply by 0.5 to reduce the amplitude of the signal by half
hat.write('docs/tutorials/renders/002-plucked-hat.flac')
def makehat(length=dsp.MS * 80):
lowhz = dsp.win('rnd', 9000, 11000)
highhz = dsp.win('rnd', 12000, 14000)
return noise.bln('sine', length, lowhz, highhz).env(pluckout) * 0.5
lfo = dsp.win('sinc', 0.1,
1) # Hat lengths between 100ms and 1s over a sinc window
lfo.graph('docs/tutorials/figures/002-sinc-win.png', label='sinc window')
out = dsp.buffer(length=30)
elapsed = 0
while elapsed < 30:
pos = elapsed / 30 # position in the buffer between 0 and 1
hatlength = lfo.interp(
pos
) # Sample the current interpolated position in the curve to get the hat length
hat = makehat(hatlength)
out.dub(
hat, elapsed
) # Finally, we dub the hat into the output buffer at the current time
elapsed += 0.5 # and move our position forward again a half second so we can do it all again!
out.write('docs/tutorials/renders/002-hats-on-ice.flac')
return osc.play(length)
def makebass(length, freq, lfo=0.5, amp=0.05, factor=10):
wavetable = 'square'
wtsize = 4096
ftable = [ v * factor + 1 for v in wavetables.wavetable('random', wtsize) ]
factors = [ v * ftable[i] for i, v in enumerate(wavetables.wavetable('sine', wtsize)) ]
osc = oscs.Fold(wavetable, factors, freq, lfo, amp)
return osc.play(length)
chords = []
for c in 'I I6 IV6 IV69 I I6 IV6 IV69 iii vi ii7 V11'.split(' '):
chords += [ c ] * 4
out = dsp.buffer(length=1)
length = 44100 // 4
lenmult = 4
hat = dsp.read('manys/many_300.wav')
snare = dsp.read('manys/many_400.wav')
kick = dsp.read('manys/many_500.wav')
kick = kick.speed(0.8)
def makesynths():
out = dsp.buffer(length=1)
beat = length // 2
numbeats = 16 * 8 * lenmult
pat = rhythm.topattern('x..x....')
onsets = rhythm.onsets(pat, beat, numbeats)
import random
import time
from pippi import dsp, sampler, tune, rhythm
import os
PATH = os.path.dirname(os.path.realpath(__file__))
print(__file__)
start_time = time.time()
samp = sampler.Sampler('%s/sounds/harpc2.wav' % PATH, 'c2')
out = dsp.buffer(length=32)
chords = ['iii', 'vi', 'ii', 'V']
def arp(i):
cluster = dsp.buffer()
length = random.randint(44100, 44100 + 22050)
numnotes = random.randint(3, 12)
onsets = rhythm.curve(numnotes, dsp.RND, length)
chord = chords[i % len(chords)]
freqs = tune.chord(chord, octave=random.randint(1, 3))
for i, onset in enumerate(onsets):
freq = freqs[i % len(freqs)]
note = samp.play(freq)
note = note.pan(random.random())
note *= random.triangular(0, 0.125)
cluster.dub(note, onset / cluster.samplerate)
return cluster
from pippi import dsp
import mml2music
import os
with open('input.mml', 'r') as file:
mml = file.read().lower()
parser = mml2music.MMLParser()
track = parser.get_notes(mml, max_length=-1, max_notes=200)
print(f'Parsed {len(track.notes)} notes.\nTotal length: {track.position}')
track.reverse()
out = dsp.buffer(channels=1, samplerate=48000)
writer = mml2music.Writer(
f'{os.path.dirname(os.path.abspath(__file__))}/sounds/flute', out)
writer.compose(track)
writer.export('renders/output48_reversed.wav')
print('Done!')
import random
import time
from pippi import dsp, oscs, tune, wavetables
import os
PATH = os.path.dirname(os.path.realpath(__file__))
print(__file__)
start_time = time.time()
tlength = 20
out = dsp.buffer(length=tlength)
pos = 0
count = 0
count2 = 0
def make_note(freq, amp, length):
lfo = dsp.SINE
lfo_freq = random.triangular(0.001, 15)
# Frequency modulation wavetable
mod = wavetables.randline(random.randint(10, 30))
# Frequency of the freq mod wavetable
mod_freq = random.triangular(0.001, 2)
# Range / depth of the freq mod wavetable
mod_range = random.triangular(0, 0.025)
pulsewidth = random.random()
# Fill up a stack of wavetables to give to the Osc.
A = dsp.rand(minval, maxval)
B = dsp.rand(minval, maxval)
numbranches = numgrains // grainsperbranch
if A > B:
A, B = B, A
trunk = dsp.win('rsaw', A, B)
trunk.graph('trunk-%s-rsaw.png' % numgrains, y=(0,1))
branches = []
for _ in range(numbranches):
bD = dsp.rand(0.001, 0.999) # delta
bA = dsp.rand(max(A - (bD/2), 0), min(A + (bD/2), 1))
branches += [ dsp.buffer(dsp.win('rsaw', bA, B), channels=1) ]
branches = dsp.stack(branches)
branches.graph('branches-%s-rsaw.png' % numgrains, y=(0,1))
curve = shapes.win('hann', length=0.1)
trunk = dsp.win(curve, A, B)
trunk.graph('trunk-%s-randhann.png' % numgrains, y=(0,1))
branches = []
for _ in range(numbranches):
bD = dsp.rand(0.001, 0.999) # delta
bA = dsp.rand(max(A - (bD/2), 0), min(A + (bD/2), 1))
branches += [ dsp.buffer(dsp.win(curve, bA, B), channels=1) ]
branches = dsp.stack(branches)
from pippi import dsp, rhythm
import random
# Create an empty buffer to dub sounds into
out = dsp.buffer()
# Load a snare drum sample from the `sounds` directory
snare = dsp.read('sounds/snare.wav')
# Make a random number of passes dubbing into the
# output buffer. On each pass...
numpasses = random.randint(4, 8)
for _ in range(numpasses):
# Set the length of the
length = random.randint(44100, 44100 * 30)
# Pick a random number of beats / events
numbeats = random.randint(16, 64)
# If `rhythm.curve` get reverse=True, the window function will be
# read in reverse -- high to low.
reverse = random.choice([True, False])
# Randomly choose a window function for `rhythm.curve`
wintype = random.choice(
['sine', 'tri', 'kaiser', 'hann', 'blackman', None])
# If wintype is None, generate a random list of values to use as a wavetable
wavetable = None if wintype is not None else [
random.random() for _ in range(random.randint(3, 10))
1,
math.sqrt(5) * 0.5,
math.sqrt(6) * 0.5,
math.sqrt(7) * 0.5,
math.sqrt(2),
math.sqrt(9) * 0.5,
math.sqrt(10) * 0.5,
math.sqrt(11) * 0.5,
math.sqrt(3),
math.sqrt(13) * 0.5,
math.sqrt(14) * 0.5,
math.sqrt(15) * 0.5,
2,
]
out = dsp.buffer()
osc = oscs.Osc()
osc.amp = 0.5
length = 44100//10
pos = 0
for freq in scale * 8:
osc.freq = freq * 330
note = osc.play(length)
note = note.env('phasor')
out.dub(note, pos)
pos += int(length * 0.8)
out.write('howdoesit.wav')
