"dryAmp": 1.0, # 0..2
"psAmp": 1.0, # 0..2
"delayAmp": 0.0, # 0..2
"dryPan": 0.0, # -1..+1
"psPan": 0.0, # -1..+1
"delayPan": 0.0
} # -1..+1
class PitchShifter(Program):
def __init__(self, name):
super(PitchShifter, self).__init__(name, "PitchShifter", prototype)
self.performance = performance()
program_bank = ProgramBank(PitchShifter("Init"))
program_bank.enable_undo = False
def pitchshifter(slot, name, **pmap):
p = PitchShifter(name)
for param, dflt in prototype.items():
try:
value = pmap[param]
except KeyError:
value = dflt
p[param] = float(value)
program_bank[slot] = p
return p
"scaleD": 1.0,
"biasD": 0.0,
"muteD": 0,
"masterScale": 1.0,
"masterBias": 0.0,
"masterMute": 0
}
class Controlmixer(Program):
def __init__(self, name):
super(Controlmixer, self).__init__(name, "ControlMixer", prototype)
self.performance = performance()
program_bank = ProgramBank(Controlmixer("Init"))
program_bank.enable_undo = False
def controlmixer(slot,
name,
scaleA=1.0,
biasA=0.0,
muteA=0,
scaleB=1.0,
biasB=0.0,
muteB=0,
scaleC=1.0,
biasC=0.0,
muteC=0,
scaleD=1.0,
"bDecay2": 0.0,
"bRelease": 0.0,
"bBreakpoint": 1.0,
"bSustain": 1.0,
"bEnvmode": 0,
"bInvert": 0
}
class Envgen(Program):
def __init__(self, name):
super(Envgen, self).__init__(name, Envgen, prototype)
self.performance = performance()
program_bank = ProgramBank(Envgen("Init"))
program_bank.enable_undo = False
def envgen(slot,
name,
aAttack=0.0,
aDecay1=0.0,
aDecay2=0.0,
aRelease=0.0,
aBreakpoint=1.0,
aSustain=1.0,
aEnvmode=0,
aInvert=0,
bAttack=0.0,
bDecay1=0.0,
"delay" : 0.01,
"modDepth" : 0.5,
"feedback" : 0.0,
"lowpass" : 16000,
"dryMix" : 0.5,
"wet1Mix" : 0.5,
"wet2Mix" : 0.5,
"xmodDepth" : 0.0}
class Scanner(Program):
def __init__(self,name):
super(Scanner,self).__init__(name,Scanner,prototype)
self.performance = performance()
program_bank = ProgramBank(Scanner("Init"))
program_bank.enable_undo = False
def scanner(slot, name,
scanRate = 5.0,
wave = 0.5,
delay = 0.01,
modDepth = 0.5,
feedback = 0.0,
lowpass = 16000,
dryMix = 0.5,
wet1Mix = 0.5,
wet2Mix = 0.5,
xmodDepth = 0.0):
def fval(x):
return round(float(x),4)
"gain" : 1.0, # fold/wrap pregain 0..10?
"wave" : 0, # wave select [0,1,2] -> [None,Soft, Distort,Fold,Wrap]
"clockFreq" : 10000, # sample clock frequency
"resampleEnable" : 1, # 0 -> bypass, 1 -> resample
"low" : 20000, # low pass filter cutoff
"wet" : 0.5, # wet signal amp
"dry" : 0.5, # dry signal amp
"amp" : 1.0} # overall amp
class Crusher(Program):
def __init__(self, name):
super(Crusher, self).__init__(name, "Crusher", prototype)
self.performance = performance()
program_bank = ProgramBank(Crusher("Init"))
program_bank.enable_undo = False
def crusher(slot, name,
gain = 1.0,
wave = 0,
clockFreq = 16000,
resampleEnable = 1,
low = 20000,
wet = 0.5,
dry = 0.5,
amp = 1.0):
p = Crusher(name)
p["gain"] = float(gain)
p["wave"] = int(wave)
p["clockFreq"] = int(clockFreq)
"f4": 1200,
"q4": 1,
"gain4": 0,
"enable4": 1,
"bleed": 0,
"amp": 0
}
class Formant(Program):
def __init__(self, name):
super(Formant, self).__init__(name, Formant, prototype)
self.performance = performance()
program_bank = ProgramBank(Formant("Init"))
program_bank.enable_undo = False
def band(n, freq=None, q=1, gain=0, enable=1):
freq = freq or (n * 440)
if enable:
flag = 1
else:
flag = 0
rs = {
"f%d" % n: int(freq),
"q%d" % n: float(q),
"gain%d" % n: int(gain),
"enable%d" % n: flag
}
"threshold": 1.0, # feedback clipping threshold, normalized
"lowcut": 10000, # feedback lowpass cutoff, Hertz
"highcut": 100, # feedback highpass cutoff, Hertz
"efxMix": 0.5, # wet/dry signal mix, 0 -> dry, 1 -> wet
"xEfxMix": 0.0, # external efx-mix modulation, normalized
"amp": 1.0
} # overall gain
class CarnalDelay(Program):
def __init__(self, name):
super(CarnalDelay, self).__init__(name, "CarnalDelay", prototype)
self.performance = performance()
program_bank = ProgramBank(CarnalDelay("Init"))
program_bank.enable_undo = False
MAX_DELAY = 1.5
def carnal(
slot,
name,
amp=-12,
delayTime=0.125,
xDelay=0.0,
wow=0.0,
wowFreq=1.0,
flutter=0,
feedback=0.5,
"gate5": 0,
"gate6": 0,
"gaten": 0,
"scale": 1.0, # float, 0..1
"bias": 0, # float -4..+4
"lag": 0.0
} # float 0..1
class Cascade(Program):
def __init__(self, name):
super(Cascade, self).__init__(name, "Cascade", prototype)
self.performance = performance()
program_bank = ProgramBank(Cascade("Init"))
program_bank.enable_undo = False
def _fill_amp_list(lst):
template = [1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00]
acc = []
for i, dflt in enumerate(template):
try:
acc.append(float(lst[i]))
except IndexError:
acc.append(dflt)
return acc
def _bool(obj):
"gainD" : 1.0,
"muteD" : 0,
"modD" : 0.0,
"panD" : 0.0,
"gain1" : 1,
"gain2" : 1}
class Mixer(Program):
def __init__(self, name):
super(Mixer, self).__init__(name, "Mixer", prototype)
self.performance = performance()
program_bank = ProgramBank(Mixer("Init"))
def mixer(slot, name,
chanA = [-99, 0.0, 0.0, 0], # [gain(db), mod-depth, pan, mute]
chanB = [-99, 0.0, 0.0, 0],
chanC = [-99, 0.0, 0.0, 0],
chanD = [-99, 0.0, 0.0, 0],
main = [0,0]):
program=Mixer(name)
def fill_channel_list(lst):
acc = []
for i,dflt in enumerate([-99.0, 0.0, 0.0, 0]):
try:
acc.append(float(lst[i]))
except (IndexError,ValueError,TypeError):
"delay": 1.0,
"feedback": 0.0,
"lagDelay": 0.0,
"enableHpDelay": 0,
"scaleDelay": 1.0,
"biasDelay": 0.0
}
class Ghostbus(Program):
def __init__(self, name):
super(Ghostbus, self).__init__(name, "GHOSTBUS", prototype)
self.performance = performance()
program_bank = ProgramBank(Ghostbus("Init"))
program_bank.enable_undo = False
def ghostbus(slot,
name,
enableMod=0,
enableHpA=0,
lagA=0.0,
scaleA=1.0,
biasA=0.0,
delay=1.0,
feedback=0.0,
lagDelay=0.0,
enableHpDelay=0,
scaleDelay=1.0,
"cFreqX": 0, # External -> freq
"q": 1, # Filter Q
"qLfo": 0, # LFO -> Q
"qX": 0, # External -> Q
"filterGain": 0, # Filter gain in db
"bleed": 0.0
} # dry signal bypass 0 -> filter 1 -> no filter
class Bandpass(Program):
def __init__(self, name):
super(Bandpass, self).__init__(name, Bandpass, prototype)
self.performance = performance()
program_bank = ProgramBank(Bandpass("Init"))
program_bank.enable_undo = False
def bandpass(slot,
name,
lfoFreq=1.0,
cFreq=1000,
cFreqLfo=0,
cFreqX=0,
q=1,
qLfo=0,
qX=0,
filterGain=0,
bleed=0.0):
p = Bandpass(name)
"d1Amp": 1.0, # vol slider
"d2Amp": 1.0, # vol slider
"dry1Pan": 0.0, # bipolar
"dry2Pan": 0.0, # bipolar
"d1Pan": 0.0, # bipolar
"d2Pan": 0.0
} # bipolar
class Chronos(Program):
def __init__(self, name):
super(Chronos, self).__init__(name, "Chronos", prototype)
self.performance = performance()
program_bank = ProgramBank(Chronos("Init"))
program_bank.enable_undo = False
def chronos(slot, name, **pmap):
p = Chronos(name)
for param, dflt in prototype.items():
try:
value = pmap[param]
except KeyError:
value = dflt
p[param] = float(value)
program_bank[slot] = p
return p
"pos": 0.0,
"lfoFreq": 1.0,
"lfoDepth": 0.0,
"xscale": 0.0,
"xbias": 0.0,
"amp": 1.0
}
class Panner(Program):
def __init__(self, name):
super(Panner, self).__init__(name, "Panner", prototype)
self.performance = performance()
program_bank = ProgramBank(Panner("Init"))
def panner(
slot,
name,
amp=0, # db
pos=0.0, # pan position (-1..+1)
lfoFreq=1.0, # Hertz
lfoDepth=0.0, # (0..1)
xscale=0.0, # external signal scale
xbias=0.0):
p = Panner(name)
p["amp"] = float(db_to_amp(amp))
p["pos"] = float(clip(pos, -1, 1))
p["lfoFreq"] = float(abs(lfoFreq))
"op%dBreakKey": 60,
"op%dLeftKeyScale": 0,
"op%dRightKeyScale": 0,
"op%dAmp": 1.0,
"op%dX": 0.0
}.items():
prototype[p % op] = v
class Io(Program):
def __init__(self, name):
super(Io, self).__init__(name, Io, prototype)
self.performance = performance()
program_bank = ProgramBank(Io("Init"))
program_bank.enable_undo = False
def vibrato(freq=7.0,
lock=1,
noise=0.3,
delay=0.0,
sens=0.1,
depth=0.0,
x=0.0,
tremRatio=1.0):
a = {
"vfreq": freq,
"vlock": lock,
"vnoise": noise,
"imodfreq": 1000, # internal modulator frequency
"imodamp": 1.0, # internal modulator linear amp
"xmodamp": 0.0, # external modulator amp
"xmodbleed": 0.0, # external mod bleed to output
"carbleed": 0.0, # carrier bleed to output
"amp": 1
} # main linear amplitude
class RingModulator(Program):
def __init__(self, name):
super(RingModulator, self).__init__(name, "RingModulator", prototype)
self.performance = performance()
program_bank = ProgramBank(RingModulator("Init"))
program_bank.enable_undo = False
def rm(slot,
name,
imodfreq=1000,
imodamp=1.0,
xmodamp=1.0,
xmodbleed=0.0,
carbleed=0.0,
amp=1.0):
p = RingModulator(name)
p["imodfreq"] = int(imodfreq)
p["imodamp"] = float(imodamp)
p["xmodamp"] = float(xmodamp)
"lpcutoff" : 16000,
"hpcutoff" : 10,
"gatted" : 0,
"modDepth" : 0.0,
"wetAmp" : 1.0,
"wetPan" : 0.75,
"dryAmp" : 1.0,
"dryPan" : 0.25}
class Rumklang(Program):
def __init__(self, name):
super(Rumklang,self).__init__(name, "Rumklang", prototype)
self.performance = performance()
program_bank = ProgramBank(Rumklang("Init"))
program_bank.enable_undo = False
MAX_DELAY = 0.33
def rumklang(slot, name,
delay = 0.0,
roomSize = 0.5,
damp = 0.5,
eq = [16000, 20], # [lp hp] in Hz
gatted = 0,
modDepth = 0.0, # external wet signal modulation
wet = [0, 0.25], # [db, pan]
dry = [0, 0.75]): # [db, pan]
p = Rumklang(name)
"gain": 1.0,
"unmuteA": 1, # 0 -> mute 1 -> unmute
"unmuteB": 1,
"unmuteC": 1,
"unmuteD": 1,
"unmute": 1
}
class ASplit(Program):
def __init__(self, name):
super(ASplit, self).__init__(name, "ASplit", prototype)
self.performance = performance()
program_bank = ProgramBank(ASplit("Init"))
def asplit(slot,
name,
gainA=0,
gainB=0,
gainC=0,
gainD=0,
gain=0,
unmuteA=1,
unmuteB=1,
unmuteC=1,
unmuteD=1,
unmute=1):
p = ASplit(name)
