コード例 #1
0
ファイル: mel.py プロジェクト: hecanjog/hcj.py
def play(ctl):
    param = ctl.get("param")

    pc = ctl.get("midi").get("pc")
    pc.setOffset(111)

    lpd = ctl.get("midi").get("lpd")

    amp = pc.get(7)

    snds = ["sounds/melodica.wav", "sounds/rhodes.wav", "sounds/chime.wav", "sounds/bell.wav", "sounds/lap.wav"]
    # snds = ['sounds/rhodes.wav']
    m = dsp.read(dsp.randchoose(snds)).data
    m = dsp.transpose(m, 0.125)
    m = dsp.transpose(m, dsp.randchoose([1, 1.5, 2, 3]) * 2 ** dsp.randint(0, 3))
    m = dsp.fill(m, dsp.stf(pc.get(15, low=0.125, high=2)))

    reverse = dsp.randchoose([True, False])
    numlayers = dsp.randint(10, 20)
    numgrains = dsp.randint(pc.geti(8, low=3, high=10), pc.geti(8, low=10, high=20))
    minlen = dsp.rand(10, 100)
    # lenranges = (dsp.rand(10, 20), dsp.rand(50, 1000))
    lenranges = (pc.get(15, low=10, high=50), pc.get(15, low=50, high=500))
    env = dsp.randchoose(["sine", "hann", "tri", "vary"])

    # out = m
    out = fx.spider(m, numlayers, numgrains, minlen, lenranges, reverse)
    out = dsp.amp(out, amp)
    # out = dsp.env(out, 'sine')
    # out = dsp.alias(out)

    return out
コード例 #2
0
ファイル: fx.py プロジェクト: hecanjog/o-ou
def smear(input, mingrain=2205, maxgrain=4410, waveform='hann', spread=0.1, drift=0.05, minpan=0.0, maxpan=1.0, minamp=0.0, maxamp=1.0):
    out = dsp.vsplit(input, mingrain, maxgrain)
    out = [ dsp.amp(grain, dsp.rand(minamp, maxamp)) for grain in out ]
    out = [ dsp.env(grain, waveform) for grain in out ]
    out = [ dsp.pan(grain, dsp.rand(minpan, maxpan)) for grain in out ]
    drift_delta = drift / 2.0
    minspeed = 1.0 - drift_delta
    maxspeed = 1.0 + drift_delta

    out = [ dsp.transpose(grain, dsp.rand(minspeed, maxspeed)) for grain in out ]

    num_shuffled_grains = int(len(out) * spread)

    # Pull a random set of grains
    shuffled_grains = []
    for i in range(num_shuffled_grains):
        index = dsp.randint(0, len(out) - 1)
        shuffled_grains += [ out.pop(index) ] 

    # Insert them back into random positions
    for grain in shuffled_grains:
        index = dsp.randint(0, len(out) - 1)
        out.insert(index, grain)

    out = ''.join(out)

    return out
コード例 #3
0
ファイル: climbing.py プロジェクト: hecanjog/geodes.py
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
コード例 #4
0
ファイル: jbutler.py プロジェクト: hecanjog/jbutler
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
コード例 #5
0
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)
コード例 #6
0
ファイル: boone.py プロジェクト: hecanjog/nomadpalace-wmse
def play(voice_id):
    tel = bot.getTel()

    degrees = [ dsp.randchoose([1, 2, 3, 5, 6, 8]) for f in range(dsp.randint(2, 20)) ]
    #degrees = [ dsp.randchoose([1, 5, 6, 7, 8]) for f in range(dsp.randint(2, 10)) ]

    octave = dsp.randint(1, 4)

    freqs = tune.fromdegrees(degrees, root='c', octave=octave, ratios=tune.terry)

    out = ''

    for r in range(dsp.randint(2, 20)):
        freq = dsp.randchoose(freqs)
        waveform = dsp.randchoose(['tri', 'sine2pi'])

        length = dsp.randint(dsp.mstf(1), dsp.mstf(4000))
        #length = dsp.mstf(1500)
        #length = dsp.mstf(2500)

        pulsewidth = dsp.rand(0.01, 1)

        mod = dsp.breakpoint([ dsp.rand() for b in range(int(round(tel['density'])) + 3) ], 512)
        window = dsp.breakpoint([0] + [ dsp.rand() for b in range(int(round(tel['harmonicity'] * 2)) + 3) ] + [0], 512)
        waveform = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for b in range(int(round(tel['roughness'] * dsp.randint(1, 4))) + 3) ] + [0], 512)

        modRange = dsp.rand(0.01, 100.08)

        modFreq = dsp.rand(0.0001, 5)

        volume = dsp.rand(0.2, 0.3) * (tel['density'] / 10.0)
        #volume = dsp.rand(0.2, 0.8)

        t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
        #t = dsp.tone(length, freq, waveform)

        t = dsp.pan(t, dsp.rand())

        t = dsp.alias(t)

        t = dsp.amp(t, dsp.rand(0.5, 15.0))

        t = dsp.pad(t, 0, dsp.randint(dsp.mstf(1), dsp.mstf(10)))

        t = dsp.amp(t, dsp.rand(0.5, 0.95))

        t = dsp.env(t, 'sine')
        #t = dsp.env(t, 'phasor')

        #t = dsp.pine(t, dsp.flen(t) * 4, freq)

        out += t


    dsp.log('')
    dsp.log('boone')
    dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
    bot.show_telemetry(tel)

    return out
コード例 #7
0
ファイル: drums.py プロジェクト: hecanjog/hcj.py
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
コード例 #8
0
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
コード例 #9
0
ファイル: roll.py プロジェクト: hecanjog/hcj.py
def play(ctl):
    param = ctl.get("param")

    # lpd = ctl.get('midi').get('lpd')
    # pc = ctl.get('midi').get('pc')
    # pc.setOffset(111)

    # r = dsp.read('sounds/roll.wav').data
    r = dsp.read("sounds/pills.wav").data
    r = dsp.fill(r, dsp.stf(3))
    # tr = pc.get(10, low=0.125, high=4)
    tr = dsp.rand(0.125, 4)
    r = dsp.transpose(r, dsp.rand(tr * 0.25, tr * 2))
    # r = dsp.amp(r, pc.get(1, low=0, high=10))
    r = dsp.amp(r, dsp.rand(0, 10))

    reverse = dsp.randchoose([True, False])
    # numgrains = pc.geti(2, low=5, high=20)
    numgrains = dsp.randint(5, 20)
    # numlayers = pc.geti(3, low=5, high=50)
    numlayers = dsp.randint(5, 50)
    # minlen = lpd.get(9, low=10, high=100)
    minlen = dsp.rand(10, 100)
    # lenranges = (lpd.get(9, low=10, high=50), lpd.get(9, low=50, high=500))
    lenranges = (dsp.rand(10, 50), dsp.rand(50, 500))

    out = fx.spider(r, numlayers, numgrains, minlen, lenranges, reverse)
    # out = dsp.mix([out, dsp.env(r, 'sine')])

    return out
コード例 #10
0
    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())
コード例 #11
0
ファイル: score.py プロジェクト: lettersonsounds/twenty
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
コード例 #12
0
ファイル: curvebeats.py プロジェクト: hecanjog/sketches
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
コード例 #13
0
ファイル: sto.py プロジェクト: hecanjog/hcj.py
def play(ctl):
    def stream(length, numsegments, freq):

        out = []
        seglength = dsp.randint(100, 300)
        points = [ dsp.rand(-1, 1) for _ in range(dsp.randint(10, 20)) ]

        for _ in range(numsegments):
            seglength = dsp.cap(seglength + dsp.randint(-5, 5), 1000, 100)
            points = [ dsp.cap(p + dsp.randint(-0.1, 0.1), 1, -1) for p in points ]

            out += dsp.breakpoint([0] + points + [0], seglength)

        print len(out), freq, length

        out = dsp.ctone(freq, dsp.stf(length), out, dsp.rand(0.1, 0.5))
        #out = dsp.env(out, 'random')

        return out

    numstreams = dsp.randint(20, 30)
    out = ''

    for _ in range(numstreams):
        length = dsp.rand(100, 500) / 1000.0
        numsegments = dsp.randint(100, 200)
        freq = dsp.rand(200, 1000)
        out += stream(length, numsegments, freq)

    #out = dsp.env(out, 'random')

    return out
コード例 #14
0
ファイル: jbutler.py プロジェクト: hecanjog/jbutler
 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
コード例 #15
0
    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
コード例 #16
0
ファイル: fx.py プロジェクト: hecanjog/hcj.py
def penv(snd, low=4, high=20):
    packets = dsp.split(snd, dsp.dsp_grain)

    ptable = dsp.breakpoint([ dsp.rand() for _ in range(dsp.randint(low, high)) ], len(packets))
    etable = dsp.breakpoint([0] + [ dsp.rand() for _ in range(dsp.randint(low, high)) ] + [0], len(packets))

    packets = [ dsp.pan(p, ptable[i], etable[i]) for i, p in enumerate(packets) ]

    return ''.join(packets)
コード例 #17
0
def makeLongChord(seg):
    degrees = [dsp.randint(1, 9) for _ in range(dsp.randint(2, 4))]
    long_chord = chord(sum(seg), [
        freq * 2**dsp.randint(0, 5)
        for freq in tune.fromdegrees(degrees, octave=1, root=key)
    ], dsp.rand(0.15, 0.35))
    long_chord = dsp.fill(long_chord, sum(seg))

    return long_chord
コード例 #18
0
ファイル: score.py プロジェクト: lettersonsounds/sing
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
コード例 #19
0
    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)
コード例 #20
0
ファイル: slurp.py プロジェクト: hecanjog/geodes-minorg
def play(voice_id):
    volume = P(voice_id, 'volume', 100.0)
    volume = volume / 100.0 # TODO: move into param filter
    volume = volume * 0.65
    length = P(voice_id, 'length', 40)
    env    = False
    wii    = False
#    wii    = True

    speed  = False
    
    numcycles = dsp.randint(1, 200)

    # Make breakpoint env with 2-10 vals between 0.1 and 1.0
    curve_a = dsp.breakpoint([1.0] + [dsp.rand(0.1, 1.0) for r in range(dsp.randint(2, 10))] + [0], numcycles)

    # Make wavetable with single cycle from given wave types
    curve_types = ['vary', 'phasor', 'sine', 'cos', 'impulse']
    curve_b = dsp.wavetable(dsp.randchoose(curve_types), numcycles)

    # Make pan curve - always cosine
    pan = dsp.breakpoint([ dsp.rand() for i in range(dsp.randint(5, 50)) ], numcycles)
    amps = dsp.breakpoint([ dsp.rand(0.1, 0.75) for i in range(dsp.randint(5, 30)) ], numcycles)

    # Multiply breakpoint curve with simple wavetable
    wtable = [ curve_a[i] * curve_b[i] for i in range(numcycles) ]

    # Scale to max frequency
    wtable = [ (f * 20000) + length for f in wtable ]

    # Possible osc wavetypes
    wtypes = ['sine2pi']
#    wtypes = ['tri', 'sine2pi', 'impulse']
#    wtypes = ['impulse', 'tri', 'cos', 'sine2pi', 'vary']

    if wii is True:
        out = [ dsp.pan(dsp.cycle(wtable[i], dsp.randchoose(wtypes)), pan[i]) for i in range(numcycles) ]
    else:
        wtype = dsp.randchoose(wtypes)
        out = [ dsp.pan(dsp.cycle(wtable[i], wtype), pan[i]) for i in range(numcycles) ]

    out = [ dsp.amp(oo, amps[i]) for i, oo in enumerate(out) ]

    out = dsp.amp(''.join(out), volume)

    if speed != False and speed > 0.0:
        out = dsp.transpose(out, speed)

    if env != False:
        out = dsp.env(out, env)

    return out
コード例 #21
0
def makeShape():
    shape = []

    num_shapelets = dsp.randint(3, 8)

    for _ in range(num_shapelets):
        shapelet_size = dsp.randint(20, 100)
        num_points = dsp.randint(4, shapelet_size / dsp.randint(3, 4))
        shapelet = dsp.breakpoint([ dsp.rand() for _ in range(num_points) ], shapelet_size)

        shape += shapelet

    return shape
コード例 #22
0
ファイル: study.ix.py プロジェクト: hecanjog/pattern.studies
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)
コード例 #23
0
ファイル: boing.py プロジェクト: hecanjog/geodes-minorg
def play(voice_id):
    bpm = config('bpm')
    root = config('key')
    quality = getattr(tune, config('quality'))
    ratios = getattr(tune, config('tune'))

    bendfactor = 0.05
    #    bendfactor = 0

    bdiv = 4
    bdiv *= dsp.randchoose([16, 24, 32])
    loctave = 1
    hoctave = 4

    si = 32 * dsp.randint(1, 2)
    beat = dsp.bpm2frames(bpm) / bdiv

    y = [easeOutQuad(float(i), 0, 1, si) for i in range(si)]
    z = [easeOutQuad(float(i), 0, 1, si) for i in reversed(range(si))]

    freqs = tune.fromdegrees([1, 2, 3, 4, 5, 6, 7, 8],
                             root=root,
                             octave=dsp.randint(loctave, hoctave),
                             ratios=ratios,
                             scale=quality)
    freqs = freqs[:dsp.randint(1, len(freqs))]
    if dsp.rand() > 0.5:
        freqs = [f for f in reversed(freqs)]
    freqs = dsp.rotate(freqs, dsp.randint(0, len(freqs)))

    y = y + z

    y = [dsp.mstf(v * beat) + dsp.mstf(2) for v in y]

    x = range(len(y))

    def make(length, freq):
        freq *= dsp.rand(1 - (bendfactor / 2.0), 1 + (bendfactor / 2.0))
        out = keys.chippy(length=int(length * dsp.rand(0.01, 0.4)),
                          freq=freq,
                          amp=0.7)
        out = dsp.env(out, 'phasor')
        out = dsp.pad(out, 0, length - dsp.flen(out))
        return out

    out = [make(v, freqs[i % len(freqs)]) for i, v in enumerate(y)]
    out = ''.join(out)

    out = dsp.pan(out, dsp.rand(0, 1))

    return out
コード例 #24
0
def makeShape():
    shape = []

    num_shapelets = dsp.randint(3, 8)

    for _ in range(num_shapelets):
        shapelet_size = dsp.randint(20, 100)
        num_points = dsp.randint(4, shapelet_size / dsp.randint(3, 4))
        shapelet = dsp.breakpoint([dsp.rand() for _ in range(num_points)],
                                  shapelet_size)

        shape += shapelet

    return shape
コード例 #25
0
def play(voice_id):
    tel = bot.getTel()

    freqs = tune.fromdegrees([ dsp.randchoose([1, 2, 3, 5, 6, 8]) for f in range(dsp.randint(2, 5)) ], root='c', octave=dsp.randint(1, 3), ratios=tune.just)

    out = ''

    for freq in freqs:
        waveform = dsp.randchoose(['tri', 'sine2pi'])
        length = dsp.randint(dsp.mstf(10), dsp.mstf(300))
        #length = dsp.mstf(150)
        pulsewidth = dsp.rand()

        mod = dsp.breakpoint([ dsp.rand() for b in range(int(round(tel['density'])) + 3) ], 512)
        window = dsp.breakpoint([0] + [ dsp.rand() for b in range(int(round(tel['harmonicity'] * 2)) + 3) ] + [0], 512)
        waveform = dsp.breakpoint([0] + [ dsp.rand(-1, 1) for b in range(int(round(tel['roughness'] * 3)) + 3) ] + [0], 512)

        modRange = 0.005
        modFreq = dsp.rand(0.0001, 5)

        volume = dsp.rand(0.2, 0.3)

        if dsp.rand(0, 100) > 50:
            t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
        else:
            t = dsp.tone(length, freq, waveform)

        #t = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, volume)
        #t = dsp.tone(length, freq, waveform)

        t = dsp.pan(t, dsp.rand())
        t = dsp.alias(t)

        t = dsp.amp(t, dsp.rand(0.5, 5.0))

        t = dsp.pad(t, 0, dsp.randint(dsp.mstf(1), dsp.mstf(500)))
        #t = dsp.pad(t, 0, dsp.mstf(100))
        t = dsp.amp(t, dsp.rand(0.5, 0.75))

        #out += dsp.env(t, 'sine')
        out += t

    #out = dsp.env(t, 'sine')

    dsp.log('')
    dsp.log('boone')
    dsp.log('%s length: %.2f' % (voice_id, dsp.fts(dsp.flen(out))))
    bot.show_telemetry(tel)

    return out
コード例 #26
0
ファイル: score.py プロジェクト: lettersonsounds/slowly
def that(li):
    print 'layer', li

    freqs = tune.fromdegrees([ dsp.randint(1, 20) for f in range(dsp.randint(3, 6)) ], octave = 3)

    length = dsp.stf(dsp.rand(10, 20))

    layers = []

    for fi, freq in enumerate(freqs):
        print '    tone', fi, round(dsp.fts(length), 2)

        waveform = dsp.randchoose(['sine2pi', 'tri', 'hann'])
        waveform = dsp.wavetable(waveform, 512)

        window = dsp.randchoose(['sine', 'tri', 'hann'])
        window = dsp.wavetable(window, 512)

        pulsewidth = dsp.rand(0.1, 1)
        modFreq    = dsp.rand(0.1, 10.0) / dsp.fts(length)

        numgrains = length / 32
        numpoints = dsp.randint(2, 6)

        apoints = [0] + [dsp.rand(0, 1) for p in range(numpoints - 2)] + [0]
        ppoints = [dsp.rand(0, 1) for p in range(numpoints)]

        e = dsp.breakpoint(apoints, numgrains)
        p = dsp.breakpoint(ppoints, numgrains)

        mod = dsp.wavetable('random', 512)
        modRange = dsp.rand(0, 0.001)

        print '    ', round(freq, 2), round(modRange, 3), round(modFreq, 3)
        layer = dsp.pulsar(freq, length, pulsewidth, waveform, window, mod, modRange, modFreq, 0.1)

        layer = dsp.split(layer, dsp.flen(layer) / numgrains)
        layer = layer[:numgrains]

        layer = [ dsp.pan(dsp.amp(layer[i], e[i]), p[i]) for i in range(numgrains) ]

        layer = ''.join(layer)

        layers += [ layer ]

    out = dsp.mix(layers)

    return out
コード例 #27
0
ファイル: basic.py プロジェクト: hecanjog/algotalk
 def gamutScale():
     num_notes = dsp.randint(3, 6)
     scale = [
         dsp.randchoose([1, 2, 3, 4, 5, 6, 7, 8]) for _ in range(num_notes)
     ]
     freqs = tune.fromdegrees(scale, octave=octave, root=key)
     return freqs
コード例 #28
0
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)
コード例 #29
0
ファイル: clap.py プロジェクト: hecanjog/geodes-minorg
    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
コード例 #30
0
ファイル: safari.py プロジェクト: hecanjog/hcj.py
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
コード例 #31
0
ファイル: bells.py プロジェクト: hecanjog/geodes.py
def play(ctl):
    #out = snds.load('genie/piano.wav')

    lenrange = 300
    minlen = 1

    if dsp.rand() > 0.5:
        lengths = dsp.breakpoint([dsp.rand(0, 1) for _ in range(5)], 50)
    else:
        lengths = dsp.wavetable('sine', 50)

    lengths = [dsp.mstf(l * lenrange + minlen) for l in lengths]

    out = ''

    for length in lengths:
        freq = tune.ntf('f', octave=dsp.randint(2, 5))

        if dsp.rand() > 10.85:
            length = dsp.stf(dsp.rand(0.5, 3))
            freq = dsp.randchoose(
                tune.fromdegrees([1, 3, 4, 5, 6], octave=4, root='f'))

        out += keys.pulsar(freq=freq, length=length, env='phasor')

        if dsp.rand() > 10.75:
            freq = dsp.randchoose(
                tune.fromdegrees([1, 3, 4, 5, 6], octave=4, root='f'))

    return out
コード例 #32
0
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
コード例 #33
0
ファイル: rhodes.py プロジェクト: hecanjog/amber
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
コード例 #34
0
ファイル: amber.py プロジェクト: lettersonsounds/amber
        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 = dsp.rotate(arp_degrees, vary=True)
            arp_notes = tune.fromdegrees(arp_degrees[:reps], oct, '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) ]

                arp_one = dsp.tone(arp_length, wavetype='tri', freq=arp_pair[0], amp=0.075)
                arp_one = dsp.env(arp_one, 'random')

                arp_two = dsp.tone(arp_length, wavetype='tri', freq=arp_pair[1], amp=0.08)
                arp_two = dsp.env(arp_two, 'random')

                arps += arp_one + arp_two
                arp_count += 2

            arps = dsp.env(arps, 'random')
            arps = dsp.pan(arps, dsp.rand())

            return arps
コード例 #35
0
ファイル: study.xii.py プロジェクト: hecanjog/pattern.studies
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
コード例 #36
0
ファイル: rhodes.py プロジェクト: hecanjog/pattern.studies
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
コード例 #37
0
ファイル: fx.py プロジェクト: hecanjog/hcj.py
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)
コード例 #38
0
def play(voice_id):
    bpm = config('bpm')
    key = config('key')
    quality = getattr(tune, config('quality')) 
    ratios = getattr(tune, config('tune')) 

    beat = dsp.bpm2frames(bpm)
    nlen = beat / dsp.randchoose([4,5,6,7,8,9,10])

    root = 340.0
    target = tune.ntf(key)

    n = dsp.read('sounds/mike.wav').data
    n = dsp.transpose(n, target / root)
    n = dsp.amp(n, 0.4)

    length = dsp.randint(16, 64) * beat
    ngrains = length / nlen

    n = dsp.transpose(n, dsp.randchoose([0.5, 1, 2, 2, 4, 4]))
    n = dsp.split(n, nlen)

    snd = dsp.randchoose(n)
    snd = dsp.env(snd, 'sine')

    grains = [ snd for i in range(ngrains) ]
    grains = [ dsp.pan(grain, dsp.rand()) for grain in grains ]

    out = ''.join(grains)
    out = dsp.env(out, 'sine')

#    out = dsp.pad(out, 0, dsp.stf(dsp.randint(0.5, 3)))

    return out
コード例 #39
0
    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
コード例 #40
0
def smear(snd):
    snd = dsp.split(snd, dsp.mstf(dsp.rand(5000, 10000)))
    snd = dsp.randshuffle(snd)
    snd = [dsp.env(s) for s in snd]
    snd = [s * dsp.randint(1, 8) for s in snd]

    return dsp.drift(''.join(snd), dsp.rand(0.01, 0.1))
コード例 #41
0
ファイル: jbutler.py プロジェクト: hecanjog/jbutler
def smear(snd):
    snd = dsp.split(snd, dsp.mstf(dsp.rand(5000, 10000)))
    snd = dsp.randshuffle(snd)
    snd = [ dsp.env(s) for s in snd ]
    snd = [ s * dsp.randint(1, 8) for s in snd ]

    return dsp.drift(''.join(snd), dsp.rand(0.01, 0.1))
コード例 #42
0
ファイル: rollsnwavesagain.py プロジェクト: hecanjog/sketches
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
コード例 #43
0
ファイル: __init__.py プロジェクト: hecanjog/hcj.py
    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
コード例 #44
0
ファイル: study.xii.py プロジェクト: hecanjog/pattern.studies
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
コード例 #45
0
ファイル: 2015-03-08-scribble.py プロジェクト: hecanjog/haiku
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
コード例 #46
0
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
コード例 #47
0
ファイル: orc.py プロジェクト: hecanjog/o-ou
def hihat(amp, length):
    if amp == 0:
        return dsp.pad('', 0, length)

    def hat(length):
        lowf = dsp.rand(600, 7000)
        highf = dsp.rand(7000, 19000)
        
        if dsp.randint(0, 6) == 0:
            out = dsp.bln(length, lowf, highf)
            out = dsp.env(out, 'line')
        else:
            out = dsp.bln(int(length * 0.05), lowf, highf)
            out = dsp.env(out, 'phasor')
            out = dsp.pad(out, 0, length - dsp.flen(out))

        return out

    if dsp.randint() == 0:
        out = ''.join([ hat(length / 2), hat(length / 2) ])
    else:
        out = hat(length)

    out = dsp.amp(out, amp)
    return out
コード例 #48
0
ファイル: pat-score.py プロジェクト: hecanjog/buchla-score
def make_layer(freq):
    out = ''

    for i in range(500):
        out += make_vary(beat * dsp.randint(1, 8), freq)

    return out
コード例 #49
0
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
コード例 #50
0
ファイル: rolls.py プロジェクト: hecanjog/geodes-minorg
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
コード例 #51
0
def makeScale():
    scale = dsp.rotate([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], vary=True)
    if dsp.rand() > 0.5:
        scale.reverse()

    for _ in range(4, 8):
        scale.pop(dsp.randint(0, len(scale) - 1))

    return scale
コード例 #52
0
ファイル: test_soundfont.py プロジェクト: smutek/pippi
    def test_playall(self):
        events = []
        pos = 0
        length = 10

        while pos < length:
            events += [
                dict(start=pos,
                     length=dsp.rand(0.2, 3),
                     freq=30 * dsp.randint(1, 10),
                     amp=dsp.rand(),
                     voice=dsp.randint(0, 127))
            ]

            pos += dsp.rand(0.01, 0.1)

        out = soundfont.playall("tests/sounds/florestan-gm.sf2", events)
        out = fx.norm(out, 0.5)
        out.write('tests/renders/soundfont_playall.wav')
コード例 #53
0
ファイル: weeds.py プロジェクト: hecanjog/geodes-minorg
def play(voice_id):
    reload(keys)

    bpm = config('bpm')
    root = config('key')
    quality = getattr(tune, config('quality')) 
    ratios = getattr(tune, config('tune')) 

    scale = [1,5,8]

    if dsp.rand() > 0.5:
        scale = reversed(scale)

    freqs = tune.fromdegrees(scale, root=root, octave=dsp.randint(1, 3), ratios=ratios, scale=quality)

    freqs = dsp.rotate(freqs, dsp.randint(0, len(freqs)))

    out = ''

    length = int(dsp.bpm2frames(bpm) * dsp.randchoose([0.25, 0.5, 1]) * 0.5) 
    length = dsp.bpm2frames(bpm) * 4
    length = dsp.stf(dsp.rand(1, 8))
    for n in range(dsp.randint(1, 3)):
        amp = dsp.rand(0.3, 0.65)
        freq = dsp.randchoose(freqs)
        freq = freqs[n%len(freqs)]
        b = keys.chippy(length=length, freq=freq, amp=amp)

        b = dsp.split(b, 100)

        oenvs = dsp.breakpoint([0,0,0,0] + [ dsp.rand() for i in range(len(b) / 10) ], len(b))
        opans = dsp.breakpoint([dsp.rand(0.4, 0.6)] + [ dsp.rand() for i in range(len(b) / 100) ] + [0.5], len(b))
        b = [ dsp.amp(b[i], oenvs[i]) for i in range(len(b)) ]
        b = [ dsp.pan(b[i], opans[i]) for i in range(len(b)) ]

        b = ''.join(b)
        #b = dsp.env(b, 'phasor')
        b = dsp.env(b, 'sine')

        out += b

    return out
コード例 #54
0
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
コード例 #55
0
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
コード例 #56
0
ファイル: climbing.py プロジェクト: hecanjog/geodes.py
def nextChord(last):
    degs = dsp.randshuffle(last)[:dsp.randint(1, 2)]
    for deg in degs:
        newdeg = deg + dsp.randchoose([-1, 1])
        if newdeg == 0:
            newdeg = 1
        elif newdeg > 15:
            newdeg = 15

        last[last.index(deg)] = newdeg

    return last
コード例 #57
0
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
コード例 #58
0
ファイル: 2015-02-22-fuzzlo.py プロジェクト: hecanjog/haiku
def makeLayer(freq):
    pw = dsp.rand()
    wf = dsp.wavetable('tri', 512)
    win = dsp.wavetable('hann', 512)
    mod = dsp.breakpoint([ dsp.rand() for m in range(dsp.randint(4,8)) ], 512)
    modf = dsp.rand(0.1, 2)
    modr = dsp.rand(0, 0.01)
    amp = dsp.rand(0.1, 0.5)

    layer = dsp.pulsar(freq, length, pw, wf, win, mod, modf, modr, amp)

    return layer