Esempio n. 1
0
def tuned_wind(length, freq):

    with SFMemoryZone():

        sigs = []
        for i in range(1, 3):
            sig = byquad_filter(
                'peak',
                byquad_filter(
                    'peak',
                    sf.Mix(clean_noise(length, freq),
                           sf.Pcnt10(sf.SineWave(length, freq))), 1.0, 64),
                freq, 0.1, 64)

            sig = byquad_filter('peak', sig, freq, 1.0, 128)

            sig = sf.FixSize(excite(sig, 1.0, 2.0))
            sig = sf.FixSize(sf.Saturate(sf.LinearVolume(sig, 2.0)))
            sig = create_vibrato(sig,
                                 length,
                                 longer_than=0.5,
                                 rate=2.5,
                                 at=0.45,
                                 depth=0.5,
                                 pitch_depth=0.02)

            sigs.append(sig)
        sig = mix(sigs)
        return sf.FixSize(polish(sig, freq)).keep()
Esempio n. 2
0
def folk_flute(length,freq):
    sig=mix(
        byquad_filter(
            'low',
            sf.Mix(
                phasing_triangle(length,freq),
                sf.Pcnt1(sf.MakeSquare(sf.SineWave(length,freq*0.9)))
            ),
            freq*2.0,
            2
        ),
        sf.Multiply(
            byquad_filter(
                'peak',
                clean_noise(length,freq*0.5),
                freq,
                0.5,
                16
            ),
            sf.ExponentialShape((0,-60),(64,-28),(128,-40),(length,-40))
        )
    )
    sig=create_vibrato(
        sig,length,
        longer_than=512,
        rate=2.5,
        at=450,
        depth=0.5,
        pitch_depth=0.02
    )
    return sf.FixSize(polish(sig,freq))
Esempio n. 3
0
def tremulus_oboe_filter(sig, length, freq):
    rate = 3.25
    # Clip off extreme spectra leakage (which in can have big negative compenents).
    env = sf.NumericShape((0, 0), (5, 1), (length-5, 1), (length, 0))
    sig = sf.Multiply(env, sig)
    # Filter gentally to keep the singal stable
    sig = sf.RBJLimitedPeaking(sig, freq*3, 0.2, 2.5)
    sig = sf.RBJLimitedPeaking(sig, freq*3, 0.2, 2.5)
    sig = sf.FixSize(sig)
    sig = sf.RBJLimitedPeaking(sig, freq*5, 0.5, 2)
    sig = sf.RBJLimitedPeaking(sig, freq*5, 0.5, 2)
    sig = sf.FixSize(sig)
    sig = sf.RBJLimitedPeaking(sig, freq*7, 1, 2)
    sig = sf.RBJLimitedPeaking(sig, freq*7, 1, 2)
    sig = sf.FixSize(sig)
    sig = sf.RBJNotch(sig, freq*2, 1.0, 1.0)
    sig = sf.Mix(+sig, sf.RBJNotch(sig, freq, 1.0, 1.0))
    sig = sf.FixSize(sig)
    sig = sf.RBJLowPass(sig, freq*9, 1.0)
    br = freq * 9
    if br > 5000.0:
       br = 5000.0
    sig = sf.RBJLowPass(sig, br, 1.0)
    sig = sf.FixSize(sig)
    shape = sf.SineWave(length, rate)
    shape = sf.NumericVolume(shape, 0.5)
    shape = sf.DirectMix(1.0, shape)
    filt = byquad_filter('high', +sig, freq * 4)
    filt = sf.Multiply(filt, +shape)
    sig = sf.Mix(sig, filt)
    mag = 0.01
    ev=sf.NumericVolume(shape, mag)
    ev=sf.DirectMix(1.0, ev)
    sig=sf.FrequencyModulate(sig, ev)
    return sf.FixSize(sig)
Esempio n. 4
0
def tremulus_diapason_filter(sig, freq):
    with SFMemoryZone():
        length = sf.Length(sig)
        rate = 3.0
        # Clip off extreme spectra leakage (which in can have big negative compenents).
        env = sf.LinearShape((0, 0), (5, 1), (length - 5, 1), (length, 0))
        sig = sf.Multiply(env, sig)
        # Filter gentally to keep the singal stable
        sig = sf.RBJLimitedPeaking(sig, freq * 2, 0.5, 1.0)
        sig = sf.RBJLowPass(sig, freq * 3, 1.0)
        br = freq * 9
        if br > 5000.0:
            br = 5000.0
        sig = sf.RBJLowPass(sig, br, 1.0)
        sig = sf.FixSize(sig)
        shape = sf.SineWave(length, rate)
        shape = sf.LinearVolume(shape, 0.5)
        shape = sf.DirectMix(1.0, shape)
        filt = byquad_filter('high', +sig, freq * 4)
        filt = sf.Multiply(filt, +shape)
        sig = sf.Mix(sig, filt)
        mag = 0.01
        ev = sf.LinearVolume(shape, mag)
        ev = sf.DirectMix(1.0, ev)
        sig = sf.FrequencyModulate(sig, ev)
        return sf.FixSize(sig).keep()
Esempio n. 5
0
def shawm(length, freq):
    s1 = simple_sawtooth(length, freq)
    if freq > 1000:
        s_freq = 1000
    else:
        s_freq = freq * 2.0

    sig = mix(
        s1,
        sf.Multiply(
            clean_noise(length, s_freq),
            sf.ExponentialShape((0, -60), (64, -20), (128, -30),
                                (length, -40))))

    sig = sf.FixSize(sig)
    sig = byquad_filter('peak', sig, freq * 3.0, 1, 6)
    sig = byquad_filter('low', sig, freq * 6.0, 1)
    sig = polish(sig, freq)
    return sf.FixSize(sig)
Esempio n. 6
0
def tuned_wind(length,freq):

    sigs=[]
    for i in range(1,3):
        sig=byquad_filter(
            'peak',
            byquad_filter(
                'peak',
                sf.Mix(
                    clean_noise(length,freq),
                    sf.Pcnt10(sf.SineWave(length,freq))
                ),
                1.0,
                64
            ),
            freq,
            0.1,
            64
        )
        
        sig=byquad_filter(
            'peak',
            sig,
            freq,
            1.0,
            128
        )
    
        sig=sf.FixSize(excite(sig,1.0,2.0))
        sig=sf.FixSize(sf.Saturate(sf.NumericVolume(sig,2.0)))
        sig=create_vibrato(
            sig,length,
            longer_than=0.5,
            rate=2.5,
            at=0.45,
            depth=0.5,
            pitch_depth=0.02
        )
        
        sigs.append(sig)
    sig=mix(sigs)
    return sf.FixSize(polish(sig,freq))
Esempio n. 7
0
def folk_flute(length, freq):
    sig = mix(
        byquad_filter(
            'low',
            sf.Mix(phasing_triangle(length, freq),
                   sf.Pcnt1(sf.MakeSquare(sf.SineWave(length, freq * 0.9)))),
            freq * 2.0, 2),
        sf.Multiply(
            byquad_filter('peak', clean_noise(length, freq * 0.5), freq, 0.5,
                          16),
            sf.ExponentialShape((0, -60), (64, -28), (128, -40),
                                (length, -40))))
    sig = create_vibrato(sig,
                         length,
                         longer_than=512,
                         rate=2.5,
                         at=450,
                         depth=0.5,
                         pitch_depth=0.02)
    return sf.FixSize(polish(sig, freq))
Esempio n. 8
0
def shawm(length,freq):
    s1=simple_sawtooth(length,freq)
    if freq>1000:
        s_freq=1000
    else:
        s_freq=freq*2.0
    
    sig=mix(
        s1,
        sf.Multiply(
            clean_noise(length,s_freq),
            sf.ExponentialShape((0,-60),(64,-20),(128,-30),(length,-40))
        )
    )

    sig=sf.FixSize(sig)
    sig=byquad_filter('peak',sig,freq*3.0,1,6)
    sig=byquad_filter('low', sig,freq*6.0,1)
    sig=polish(sig,freq)
    return sf.FixSize(sig)
Esempio n. 9
0
def femail_soprano_ma_filter(vox, length,freq):
    vox = vox_humana_femail_soprano_a(vox,length,freq)
    if length>128:
        qsh =sf.NumericShape((0,0.1),(120,2),  (length,0.1))
        msh =sf.NumericShape((0,1.0),(120,1.0),(length,0.0))
        mshr=sf.NumericShape((0,0.0),(120,0.0),(length,1.0))
        init=byquad_filter('low',+vox,freq,qsh)
        vox =sf.Multiply(vox ,mshr)
        init=sf.Multiply(init,msh)
        vox =mix(vox,init)
        vox=sf.FixSize(polish(vox,freq))
    return vox
Esempio n. 10
0
def vox_humana_femail_soprano_ma(length, freq):
    vox = vox_humana_femail_soprano_a(length, freq)
    if length > 128:
        qsh = sf.LinearShape((0, 0.1), (120, 2), (length, 0.1))
        msh = sf.LinearShape((0, 1.0), (120, 1.0), (length, 0.0))
        mshr = sf.LinearShape((0, 0.0), (120, 0.0), (length, 1.0))
        init = byquad_filter('low', +vox, freq, qsh)
        vox = sf.Multiply(vox, mshr)
        init = sf.Multiply(init, msh)
        vox = mix(vox, init)
        vox = sf.FixSize(polish(vox, freq))
    return vox
Esempio n. 11
0
def _distant_wind(length, freq, qCorrect = 1.25, limit = False, seed = -60):
    with SFMemoryZone():
        length += 250.0
        base = sf.Mix(
            clean_noise(length,freq*4.0),
            sf.Volume(sf.SineWave(length,freq), seed)
        )
        env = []
        # Super imposted last two postions does not matter.
        v = 0.5
        t = 0
        while t < length:
            if random.random() > 0.5:
                v *= 1.1
                if v > 1.0:
                    v = 0.9
            else:
                v *= 0.9
            env += [(t, v)]
            # Constrained random walk envelope in 100 ms steps.
            t += 100
    
        #base = sf.Multiply(sf.NumericShape(env), base)
        out = []
        xq = 1.8 if freq > 640 else 2.0 if freq > 256 else 2.5 if freq > 128 else 3.0
        xq *= qCorrect
        with SFMemoryZone():
            for q in (16, 32, 48):
                out += [
                    byquad_filter(
                        'peak' if not limit else 'limited peak',
                        base,
                        freq,
                        0.5,
                        q * xq
                    )
                ]
            out = sf.Mix(out)
            out = sf.ButterworthLowPass(out, freq*1.25, 4)
            out = sf.ButterworthLowPass(out, freq*1.25, 4).keep()
            st = sf.Cut(0, length/2.0, out)
            ed = sf.Cut(length/2.0, length, out)
            st = sf.Magnitude(st)
            ed = sf.Magnitude(ed)
        rt = st/ed
        ev = sf.NumericShape((0.0, 1.0), (length, rt))
        out = sf.Multiply(ev, out)
        return sf.FixSize(sf.Cut(250,length,out)).keep()
Esempio n. 12
0
def tremulus_flute_filter(sig, length, freq):
    rate = 3.0
    # Clip off extreme spectra leakage (which in can have big negative compenents).
    env = sf.NumericShape((0, 0), (5, 1), (length-5, 1), (length, 0))
    sig = sf.Multiply(env, sig)
    shape = sf.SineWave(length, rate)
    shape = sf.NumericVolume(shape, 0.5)
    shape = sf.DirectMix(1.0, shape)
    filt = byquad_filter('high', +sig, freq * 2)
    filt = sf.Multiply(filt, +shape)
    sig = sf.Mix(sig, filt)
    mag = 0.01
    ev=sf.NumericVolume(shape, mag)
    ev=sf.DirectMix(1.0, ev)
    sigf=sf.FrequencyModulate(+sig, ev)
    return sf.FixSize(sf.Mix(sig, sigf))
Esempio n. 13
0
def tremulus_flute_filter(sig, freq):
    with SFMemoryZone():
        length = sf.Length(sig)
        rate = 3.0
        # Clip off extreme spectra leakage (which in can have big negative compenents).
        env = sf.LinearShape((0, 0), (5, 1), (length - 5, 1), (length, 0))
        sig = sf.Multiply(env, sig)
        shape = sf.SineWave(length, rate)
        shape = sf.LinearVolume(shape, 0.5)
        shape = sf.DirectMix(1.0, shape)
        filt = byquad_filter('high', +sig, freq * 2)
        filt = sf.Multiply(filt, +shape)
        sig = sf.Mix(sig, filt)
        mag = 0.01
        ev = sf.LinearVolume(shape, mag)
        ev = sf.DirectMix(1.0, ev)
        sigf = sf.FrequencyModulate(+sig, ev)
        return sf.FixSize(sf.Mix(sig, sigf)).keep()
Esempio n. 14
0
def _distant_wind(length, freq, qCorrect=1.25, limit=False, seed=-60):
    with SFMemoryZone():
        length += 250.0
        base = sf.Mix(clean_noise(length, freq * 4.0),
                      sf.ExponentialVolume(sf.SineWave(length, freq), seed))
        env = []
        # Super imposted last two postions does not matter.
        v = 0.5
        t = 0
        while t < length:
            if random.random() > 0.5:
                v *= 1.1
                if v > 1.0:
                    v = 0.9
            else:
                v *= 0.9
            env += [(t, v)]
            # Constrained random walk envelope in 100 ms steps.
            t += 100

        #base = sf.Multiply(sf.LinearShape(env), base)
        out = []
        xq = 1.8 if freq > 640 else 2.0 if freq > 256 else 2.5 if freq > 128 else 3.0
        xq *= qCorrect
        with SFMemoryZone():
            for q in (16, 32, 48):
                out += [
                    byquad_filter('peak' if not limit else 'limited peak',
                                  base, freq, 0.5, q * xq)
                ]
            out = sf.Mix(out)
            out = sf.ButterworthLowPass(out, freq * 1.25, 4)
            out = sf.ButterworthLowPass(out, freq * 1.25, 4).keep()
            st = sf.Cut(0, length / 2.0, out)
            ed = sf.Cut(length / 2.0, length, out)
            st = sf.Magnitude(st)
            ed = sf.Magnitude(ed)
        rt = st / ed if ed != 0 else 0
        ev = sf.LinearShape((0.0, 1.0), (length, rt)).realise()
        out = sf.Multiply(ev, out)
        return sf.FixSize(sf.Cut(250, length, out)).keep()