Example #1
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')
Example #2
0
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
Example #3
0
def makeArps(length, beat, cname):
    freqs = tune.chord(cname, key, dsp.randint(1,4))
    tone = Sampler(snds.load('tones/nick.wav'), direction='fw-bw-loop', tails=False)
    freqs = dsp.randshuffle(freqs)

    beat = int((beat * 2) / dsp.randchoose([0.5, 1, 2, 3, 1.5]))

    numbeats = length / beat

    out = ''

    for i in range(numbeats):
        out += tone.play(freqs[i % len(freqs)], beat) 

    out = dsp.fill(out, length)
    out = fx.penv(out)

    return out
Example #4
0
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
Example #5
0
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
Example #6
0
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
Example #7
0
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)
Example #8
0
        layers += [ kicks ]

    if canPlay('smashes', section):
        sm = dsp.fill(smash, dsp.flen(bar))
        sm = dsp.mix([ dsp.alias(sm), fx.penv(sm) ])
        sm = dsp.amp(sm, dsp.rand(0.5, 2))
        sk = dsp.fill(skitter, dsp.flen(bar))
        sk = fx.penv(sk)

        layers += [ sm, sk ]

    if count % 4 == 0:
        layers += [ dsp.pad(flam, dsp.flen(bar) - dsp.flen(flam), 0) ]

    if canPlay('bloops', section):
        bfreqs = tune.chord(cname, key, 2)
        bloopp = 'x.x.--------' if dsp.rand() > 0.5 else 'xxx.--------'
        bloopp = bloopp if dsp.rand() > 0.65 else 'xxx.----'
        pattern = ctl.parseBeat(bloopp)
        bloops = ctl.makeBeat(pattern, [ beat / 2 for _ in range(16) ], makeBloop, bfreqs)

        layers += [ bloops ]

    if canPlay('arps', section):
        arpses = dsp.mix([ makeArps(dsp.flen(bar), beat, cname) for _ in range(dsp.randint(2,4)) ])
        layers += [ arpses ]

    if section not in ('intro', 'ending'):
        rfreqs = tune.chord(cname, key, 2)
        maxbend = 0.005 if dsp.rand() > 0.3 else 0.05
        rhodeses = makeRhodes(dsp.flen(bar), beat, rfreqs, maxbend)
#
#
xaxis = ny.arange(samples, dtype=ny.float)  #
ydata = volume * ny.sin(xaxis * omega)  #
# blanks填充获取numpy数字信号                                       #
signal = ny.resize(ydata, (samples, ))  #
scipy.io.wavfile.write('test.wav', samplerate, signal)  #
#
##################################################################

#读取test.wav文件
raw = dsp.read('test.wav')

##########  输入原先创建的正弦波,通过pippi创建一个C3调谐  ##############
#
freqs = tune.chord('I', key='C', octave=3, ratios=tune.just)  #
original_freq = tune.ntf('A1')  #
speeds = [new_freq / original_freq for new_freq in freqs]  #
pos = 0  #
beat = 1.5  #
out = dsp.buffer()  #
#参考:https://pippi.world/docs/tutorials/001-soundbuffers/        #
for speed in speeds:  #
    # 创建原始输入文件音高偏移副本                                     #
    note = raw.speed(speed)  #
    #
    # 复制到输出缓冲区中                                             #
    out.dub(note, pos)  #
    #
    # 复制高八度副本                                                #
    note = raw.speed(speed * 2)  #
Example #10
0
def get_freqs(count):
    # mahjong by wayne shorter
    chords = (['i11', 'VII69'] * 6) + (['VI9', 'VII69'] * 4) + (['VI7', 'vii7', 'III7', 'VI9', 'vi7', 'II7']) + (['i11', 'VII69'] * 6)
    chords = ['i','i','i','I','I','I69','i','i','i']
    return tune.chord(chords[count % len(chords)], octave=2)
Example #11
0
def make_wavetable():
    wtsize = random.randint(2, random.randint(3, 50))
    wavetable = [0] + [random.triangular(-1, 1)
                       for _ in range(wtsize - 2)] + [0]
    return wavetable


out = dsp.buffer()

chords = 'ii vi V7 I69'

dubhead = 0
for chord in chords.split(' ') * 8:
    chordlength = random.triangular(2, 3)  # in seconds
    freqs = tune.chord(chord, key='e', octave=2)
    numnotes = random.randint(3, 6)

    notes = []

    for _ in range(numnotes):
        notelength = random.triangular(0.1, 2)
        freq = random.choice(freqs)
        amp = random.triangular(0.1, 0.25)

        note = oscs.Osc(wavetable=make_wavetable()).play(notelength, freq, amp)
        note = note.env(dsp.RND)
        note = note.taper(0.01)
        note = note.pan(random.random())

        out.dub(note, dubhead + random.triangular(0, 0.1))
Example #12
0
 def test_get_chord(self):
     assert tune.chord('I7', key='a', octave=4, ratios=tune.just) == [440.0, 550.0, 660.0, 792.0] 
     assert tune.chord('I7', key='a', octave=3, ratios=tune.just) == [220.0, 275.0, 330.0, 396.0] 
Example #13
0
 def test_getChord(self):
     assert tune.chord('I7', key='a', octave=4,
                       ratios=tune.just) == [440.0, 550.0, 660.0, 792.0]
     assert tune.chord('I7', key='a', octave=3,
                       ratios=tune.just) == [220.0, 275.0, 330.0, 396.0]
Example #14
0
def get_freqs(count):
    chords = ['II', 'V9', 'vii*', 'IV7']
    return tune.chord(chords[count % len(chords)])
Example #15
0
    return out


for i in range(numbars):
    bar = dsp.buffer()

    numlayers = random.randint(3, 6)
    beat = int(((60000 / 109) / 1000) * 44100) // 4

    if i // 4 % 3 == 0:
        chord = chords2[i % len(chords2)]
    else:
        chord = chords[i % len(chords)]

    freqs = tune.chord(chord, octave=3, key='d')

    if i > 3:
        for _ in range(numlayers):
            pattern = rhythm.pattern(16, random.randint(2, 6),
                                     random.randint(0, 3))
            onsets = rhythm.onsets(pattern, beat)
            for onset in onsets:
                if random.random() > 0.5:
                    osc.freq = random.choice(freqs)
                    osc.wavetable = [0] + [
                        random.triangular(-1, 1)
                        for _ in range(random.randint(3, 10))
                    ] + [0]
                    osc.amp = 0.5
                    snd = osc.play(random.randint(441, 44100))
Example #16
0
def test_getChord():
    assert tune.chord('I7', key='a', octave=4, ratios=tune.just) == [440.0, 550.0, 660.0, 792.0] 
Example #17
0
    ohats = drums.parsebeat(ohat, 8, beat, length, makeOHat, 0)
    kicks = drums.parsebeat(kick, 8, beat, length, makeKick, 0)
    snares = drums.parsebeat(snare, 8, beat, length, makeSnare, 0)
    lsnares = drums.parsebeat(lsnare, 8, beat, length, makeLSnare, 0)

    snaresnstuff = dsp.mix([ohats,snares])
    snaresnstuff= dsp.split(snaresnstuff, dsp.flen(snaresnstuff) / 32)
    snaresnstuff = dsp.randshuffle(snaresnstuff)
    snaresnstuff = [ dsp.env(sns, 'phasor') for sns in snaresnstuff ]
    snaresnstuff = ''.join(snaresnstuff)
    snaresnstuff = dsp.amp(snaresnstuff, 0.5)

    bar = dsp.mix([kicks,lsnares,snares,hats,ohats,snaresnstuff])
    #bar = dsp.mix([hats,ohats])

    if count % 4 == 0:
        bar = dsp.mix([ bar, dsp.fill(bksnd, dsp.flen(bar), silence=True) ])

    progression = 'ii6 ii69'.split(' ')
    cname = progression[ count % len(progression) ]
    rfreqs = tune.chord(cname, key, 2)
    rhodes = makeRhodes(dsp.flen(bar), beat / 8, rfreqs)

    out += dsp.mix([ bar, dsp.fill(rhodes, dsp.flen(bar)) ])
    #out += bar

    count += 1
    elapsed += dsp.flen(bar)

dsp.write(out, '05-bumps_ii')
Example #18
0
 def test_sub_bass_movements(self):
     freqs = tune.chord('ii/i', key='a', octave=4, ratios=tune.JUST)
     self.assertEqual(freqs[0], 440.0)
Example #19
0
from pippi import dsp
from pippi import tune

chord = tune.chord('I', octave=2, key='a', ratios=tune.terry)

numsegs = 2222
length = dsp.stf(60) / numsegs
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]
Example #20
0
def pulsars(chord, length=22050, drift=0.01, speed=0.5, amp=0.1, pulsewidth=None, env='flat', key='c', octave=3):
    freqs = tune.chord(chord, key, octave)
    return dsp.mix([ pulsar(freq, length, drift, speed, amp, pulsewidth, env) for freq in freqs ])