void SocpSolverInternal::init() {
// Call the init method of the base class
FunctionInternal::init();
ni_ = getOption("ni");
print_problem_ = getOption("print_problem");
m_ = ni_.size();
const Sparsity& A = st_[SOCP_STRUCT_A];
const Sparsity& G = st_[SOCP_STRUCT_G];
const Sparsity& E = st_[SOCP_STRUCT_E];
N_ = std::accumulate(ni_.begin(), ni_.end(), 0);
casadi_assert_message(N_==G.size2(),
"SocpSolverInternal: Supplied G sparsity: number of cols ("
<< G.size2()
<< ") must match sum of vector provided with option 'ni' ("
<< N_ << ").");
casadi_assert_message(m_==E.size2(),
"SocpSolverInternal: Supplied E sparsity: number of cols ("
<< E.size2()
<< ") must match number of cone (2-norm) constraints ("
<< m_ << ").");
nc_ = A.size1();
n_ = A.size2();
casadi_assert_message(n_==G.size1(),
"SocpSolverInternal: Supplied G sparsity: number of rows ("
<< G.size1()
<< ") must match number of decision variables (cols of A): " << n_ << ".");
casadi_assert_message(n_==E.size1(),
"SocpSolverInternal: Supplied E sparsity: number of rows ("
<< E.size1()
<< ") must match number of decision variables (cols of A): " << n_ << ".");
// Input arguments
setNumInputs(SOCP_SOLVER_NUM_IN);
input(SOCP_SOLVER_G) = DMatrix::zeros(G);
input(SOCP_SOLVER_H) = DMatrix::zeros(N_, 1);
input(SOCP_SOLVER_E) = DMatrix::zeros(E);
input(SOCP_SOLVER_F) = DMatrix::zeros(m_, 1);
input(SOCP_SOLVER_A) = DMatrix::zeros(A);
input(SOCP_SOLVER_C) = DMatrix::zeros(n_);
input(SOCP_SOLVER_LBX) = -DMatrix::inf(n_);
input(SOCP_SOLVER_UBX) = DMatrix::inf(n_);
input(SOCP_SOLVER_LBA) = -DMatrix::inf(nc_);
input(SOCP_SOLVER_UBA) = DMatrix::inf(nc_);
// Output arguments
setNumOutputs(SOCP_SOLVER_NUM_OUT);
output(SOCP_SOLVER_X) = DMatrix::zeros(n_, 1);
output(SOCP_SOLVER_COST) = 0.0;
output(SOCP_SOLVER_DUAL_COST) = 0.0;
output(SOCP_SOLVER_LAM_X) = DMatrix::zeros(n_, 1);
output(SOCP_SOLVER_LAM_A) = DMatrix::zeros(nc_, 1);
output(SOCP_SOLVER_LAM_CONE) = DMatrix::zeros(m_, 1);
}
ReArr::ReArr(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, kNumPrograms, kNumParams)
{
setNumInputs(kNumInputs);
setNumOutputs(kNumOutputs);
// reset the parameters
memset(params_, 0, sizeof(params_));
}
Silence::Silence(audioMasterCallback audio_master)
: AudioEffectX(audio_master, 1, 1) {
setNumInputs(2);
setNumOutputs(2);
setUniqueID('Silence');
canProcessReplacing();
canDoubleReplacing();
vst_strncpy(program_name, "Default", kVstMaxProgNameLen);
}
void OCPSolverInternal::init(){
// Initialize the functions
ffcn_.init();
mfcn_.init();
if(!cfcn_.isNull()) cfcn_.init();
if(!mfcn_.isNull()) mfcn_.init();
// Get the number of grid points
nk_ = getOption("number_of_grid_points");
// Read final time
tf_ = getOption("final_time");
// Get the number of differential states
nx_ = ffcn_.input(DAE_X).size();
// Get the number of parameters
np_ = getOption("number_of_parameters");
// Get the number of controls
nu_ = ffcn_.input(DAE_P).size() - np_;
// Number of point constraints
nh_ = cfcn_.isNull() ? 0 : cfcn_.output().size();
// Number of point coupling constraints
ng_ = 0;
casadi_assert_message(mfcn_.getNumInputs()<=2, "Mayer term must map endstate [ (nx x 1) , (np x 1) ] to cost (1 x 1). So it needs to accept 2 matrix-valued inputs. You supplied " << mfcn_.getNumInputs());
if (mfcn_.getNumInputs()==2) {
casadi_assert_message(mfcn_.input(1).size()==np_, "Mayer term must map endstate [ (nx x 1) , (np x 1) ] to cost (1 x 1). Shape of the second input " << mfcn_.input(1).dimString() << " must match the number of parameters np " << np_);
}
// Specify the inputs
setNumInputs(OCP_NUM_IN);
input(OCP_LBX) = input(OCP_UBX) = input(OCP_X_INIT) = Matrix<double>(nx_,nk_+1,0);
input(OCP_LBU) = input(OCP_UBU) = input(OCP_U_INIT) = Matrix<double>(nu_,nk_,0);
input(OCP_LBP) = input(OCP_UBP) = input(OCP_P_INIT) = Matrix<double>(np_,1,0);
input(OCP_LBH) = input(OCP_UBH) = Matrix<double>(nh_,nk_+1,0);
input(OCP_LBG) = input(OCP_UBG) = Matrix<double>(ng_,1,0);
// Specify the outputs
setNumOutputs(OCP_NUM_OUT);
output(OCP_X_OPT) = input(OCP_X_INIT);
output(OCP_U_OPT) = input(OCP_U_INIT);
output(OCP_P_OPT) = input(OCP_P_INIT);
output(OCP_COST) = 0.;
// Call the init function of the base class
FXInternal::init();
}
void ImplicitFunctionInternal::init(){
// Initialize the residual function
if(!f_.isInit()) f_.init();
// Allocate inputs
setNumInputs(f_.getNumInputs()-1);
for(int i=0; i<getNumInputs(); ++i){
input(i) = f_.input(i+1);
}
// Allocate outputs
setNumOutputs(f_.getNumOutputs());
output(0) = f_.input(0);
for(int i=1; i<getNumOutputs(); ++i){
output(i) = f_.output(i);
}
// Call the base class initializer
FXInternal::init();
// Number of equations
N_ = output().size();
// Generate Jacobian if not provided
if(J_.isNull()) J_ = f_.jacobian(0,0);
J_.init();
casadi_assert_message(J_.output().size1()==J_.output().size2(),"ImplicitFunctionInternal::init: the jacobian must be square but got " << J_.output().dimString());
casadi_assert_message(!isSingular(J_.output().sparsity()),"ImplicitFunctionInternal::init: singularity - the jacobian is structurally rank-deficient. sprank(J)=" << sprank(J_.output()) << " (in stead of "<< J_.output().size1() << ")");
// Get the linear solver creator function
if(linsol_.isNull() && hasSetOption("linear_solver")){
linearSolverCreator linear_solver_creator = getOption("linear_solver");
// Allocate an NLP solver
linsol_ = linear_solver_creator(CRSSparsity());
// Pass options
if(hasSetOption("linear_solver_options")){
const Dictionary& linear_solver_options = getOption("linear_solver_options");
linsol_.setOption(linear_solver_options);
}
}
// Initialize the linear solver, if provided
if(!linsol_.isNull()){
linsol_.setSparsity(J_.output().sparsity());
linsol_.init();
}
// Allocate memory for directional derivatives
ImplicitFunctionInternal::updateNumSens(false);
}
void LfpDisplayNode::setNumInputs(int inputs)
{
std::cout << "Setting num inputs on LfpDisplayNode to " << inputs << std::endl;
numInputs = inputs;
setNumOutputs(0);
setPlayConfigDetails(getNumInputs(),0,44100.0,128);
LfpDisplayEditor* editor = (LfpDisplayEditor*) getEditor();
editor->updateNumInputs(inputs);
}
mdaBandisto::mdaBandisto(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 10) // programs, parameters
{
//inits here!
fParam1 = (float)1.00; //Listen: L/M/H/out
fParam2 = (float)0.40; //xover1
fParam3 = (float)0.50; //xover2
fParam4 = (float)0.50; //L drive (1)
fParam5 = (float)0.50; //M drive
fParam6 = (float)0.50; //H drive
fParam7 = (float)0.50; //L trim (2)
fParam8 = (float)0.50; //M trim
fParam9 = (float)0.50; //H trim
fParam10 = (float)0.0; //unipolar/bipolar
setNumInputs(2);
setNumOutputs(2);
setUniqueID("mdaBand"); // identify here
DECLARE_LVZ_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Multi-Band Distortion");
//calcs here!
driv1 = (float)pow(10.0,(6.0 * fParam4 * fParam4) - 1.0);
driv2 = (float)pow(10.0,(6.0 * fParam5 *fParam5) - 1.0);
driv3 = (float)pow(10.0,(6.0 * fParam6 *fParam6) - 1.0);
valve = int(fParam10 > 0.0);
if(valve)
{
trim1 = (float)(0.5);
trim2 = (float)(0.5);
trim3 = (float)(0.5);
}
else
{
trim1 = 0.3f*(float)pow(10.0,(4.0 * pow(fParam4,3.f)));//(0.5 + 500.0 * pow(fParam4,6.0));
trim2 = 0.3f*(float)pow(10.0,(4.0 * pow(fParam5,3.f)));
trim3 = 0.3f*(float)pow(10.0,(4.0 * pow(fParam6,3.f)));
}
trim1 = (float)(trim1 * pow(10.0, 2.0 * fParam7 - 1.0));
trim2 = (float)(trim2 * pow(10.0, 2.0 * fParam8 - 1.0));
trim3 = (float)(trim3 * pow(10.0, 2.0 * fParam9 - 1.0));
switch(int(fParam1*3.9))
{
case 0: trim2=0.0; trim3=0.0; slev=0.0; break;
case 1: trim1=0.0; trim3=0.0; slev=0.0; break;
case 2: trim1=0.0; trim2=0.0; slev=0.0; break;
default: slev=0.5; break;
}
fi1 = (float)pow(10.0,fParam2 - 1.70); fo1=(float)(1.0 - fi1);
fi2 = (float)pow(10.0,fParam3 - 1.05); fo2=(float)(1.0 - fi2);
fb1 = fb2 = fb3 = 0.0f;
}
//------------------------------------------------------------------------------------
TutorialVST2Effect::TutorialVST2Effect (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, kNumParameters)
{
setUniqueID (CCONST('G', 'U', 'I', '0'));
setNumInputs (2);
setNumOutputs (2);
parameters[kLeftVolumeParameter] = 1.f;
parameters[kRightVolumeParameter] = 1.f;
extern AEffGUIEditor* createEditor (AudioEffectX*);
setEditor (createEditor (this));
}
SourceNode::SourceNode(const String& name_)
: GenericProcessor(name_),
dataThread(0)
{
if (getName().equalsIgnoreCase("Intan Demo Board")) {
setNumOutputs(16);
setNumInputs(0);
} else if (getName().equalsIgnoreCase("Custom FPGA")) {
setNumOutputs(32);
setNumInputs(0);
} else if (getName().equalsIgnoreCase("File Reader")) {
setNumOutputs(16);
setNumInputs(0);
}
setPlayConfigDetails(getNumInputs(), getNumOutputs(), 44100.0, 128);
//sendActionMessage("Intan Demo Board source created.");
//sendMessage("Intan Demo Board source created.");
}
//-------------------------------------------------------------------------------------------------------
JackVST::JackVST (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, 1) // 1 program, 1 parameter only
{
fGain = 1.; // default to 0 dB
setNumInputs (2); // stereo in
setNumOutputs (2); // stereo out
setUniqueID ('JACK-ASinsert'); // identify
canMono (); // makes sense to feed both inputs with the same signal
canProcessReplacing (); // supports both accumulating and replacing output
strcpy (fProgramName, "Default"); // default program name
fStatus = kIsOff;
}
Convolver2::Convolver2(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 0, NUM_PARAMS) {
setNumInputs(NUM_INPUTS);
setNumOutputs(NUM_OUTPUTS);
setUniqueID(UNIQUE_ID);
editor = new Convolver2Editor(this);
core = new Convolver2Core(NUM_PARAMS, VERSION, DEF_PRODUCT);
core->setParameter(PRM_SAMPLE_RATE, getSampleRate(), true);
((Convolver2Editor*)editor)->setCore(core);
((Convolver2Core*)core)->setEditor((Convolver2Editor*)editor);
}
void FilterNode::setNumInputs(int inputs)
{
numInputs = inputs;
setNumOutputs(inputs);
if (filter != 0)
{
delete filter;
filter = 0;
}
const int nChans = inputs;
if (nChans == 16) {
filter = new Dsp::SmoothedFilterDesign
<Dsp::Butterworth::Design::BandPass // design type
<4>, // order
16, // number of channels (must be const)
Dsp::DirectFormII> // realization
(1024); // number of samples over which to fade
} else if (nChans == 32) {
filter = new Dsp::SmoothedFilterDesign
<Dsp::Butterworth::Design::BandPass // design type
<4>, // order
32 , // number of channels (must be const)
Dsp::DirectFormII> // realization
(1024); // number of samples over which to fade
// parameter changes
} else if (nChans == 10) {
filter = new Dsp::SmoothedFilterDesign
<Dsp::Butterworth::Design::BandPass // design type
<4>, // order
10 , // number of channels (must be const)
Dsp::DirectFormII> // realization
(1024); // number of samples over which to fade
// parameter changes
} else {
// send a message saying this is not implemented
}
//std::cout << "Filter created with " << getNumInputs() << " channels." << std::endl;
setFilterParameters();
}
mdaLoudness::mdaLoudness(audioMasterCallback audioMaster): AudioEffectX(audioMaster, NPROGS, NPARAMS)
{
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mdal');
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
programs = new mdaLoudnessProgram[NPROGS];
setProgram(0);
suspend();
}
Vst2413r::Vst2413r(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 0, 0),
driver_(44100)
{
if(audioMaster != NULL) {
setNumInputs(0);
setNumOutputs(1);
setUniqueID(kUniqueId);
canProcessReplacing();
isSynth();
}
suspend();
}
//-------------------------------------------------------------------------------------------------------
JackVST::JackVST (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, 1),c_jar(NULL),c_error(JARInsert::kNoErr)// 1 program, 1 parameter only
{
fGain = 1.; // default to 0 dB
setNumInputs(2); // stereo in
setNumOutputs(2); // stereo out
setUniqueID('JACK'); // identify
canProcessReplacing(); // supports both accumulating and replacing output
strcpy(programName, "Default"); // default program name
c_jar = new JARInsert('vst ');
c_error = c_jar->GetError();
}
//-------------------------------------------------------------------------------------------------------
AGain::AGain (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, 11) // 1 program, 1 parameter only
{
setNumInputs (2); // stereo in
setNumOutputs (2); // stereo out
setUniqueID ('Band'); // identify
canProcessReplacing (); // supports replacing output
canDoubleReplacing (); // supports double precision processing
fGain = 1.f; // default to 0 dB
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
UdpLog::setup( 7777, "localhost" );
}
plugin::plugin(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 1, PARAMETERS)
{
setNumInputs(2);
setNumOutputs(2);
setUniqueID(ID);
canProcessReplacing();
canDoubleReplacing();
vst_strncpy(programName, "Init", kVstMaxProgNameLen);
#if (PARAMETERS > 0)
::construct_params(params);
#endif
::construct(&data);
}
// Constructor
QpSolverInternal::QpSolverInternal(const std::vector<Sparsity> &st) : st_(st) {
casadi_assert_message(st_.size()==QP_STRUCT_NUM, "Problem structure mismatch");
const Sparsity& A = st_[QP_STRUCT_A];
const Sparsity& H = st_[QP_STRUCT_H];
n_ = H.size2();
nc_ = A.isNull() ? 0 : A.size1();
if (!A.isNull()) {
casadi_assert_message(A.size2()==n_,
"Got incompatible dimensions. min x'Hx + G'x s.t. LBA <= Ax <= UBA :"
<< std::endl <<
"H: " << H.dimString() << " - A: " << A.dimString() << std::endl <<
"We need: H.size2()==A.size2()" << std::endl);
}
casadi_assert_message(H.isSymmetric(),
"Got incompatible dimensions. min x'Hx + G'x" << std::endl <<
"H: " << H.dimString() <<
"We need H square & symmetric" << std::endl);
// Sparsity
Sparsity x_sparsity = Sparsity::dense(n_, 1);
Sparsity bounds_sparsity = Sparsity::dense(nc_, 1);
// Input arguments
setNumInputs(QP_SOLVER_NUM_IN);
input(QP_SOLVER_X0) = DMatrix::zeros(x_sparsity);
input(QP_SOLVER_H) = DMatrix::zeros(H);
input(QP_SOLVER_G) = DMatrix::zeros(x_sparsity);
input(QP_SOLVER_A) = DMatrix::zeros(A);
input(QP_SOLVER_LBA) = -DMatrix::inf(bounds_sparsity);
input(QP_SOLVER_UBA) = DMatrix::inf(bounds_sparsity);
input(QP_SOLVER_LBX) = -DMatrix::inf(x_sparsity);
input(QP_SOLVER_UBX) = DMatrix::inf(x_sparsity);
input(QP_SOLVER_LAM_X0) = DMatrix::zeros(x_sparsity);
//input(QP_SOLVER_LAM_A0) = DMatrix::zeros(x_sparsity);
// Output arguments
setNumOutputs(QP_SOLVER_NUM_OUT);
output(QP_SOLVER_X) = DMatrix::zeros(x_sparsity);
output(QP_SOLVER_COST) = 0.0;
output(QP_SOLVER_LAM_X) = DMatrix::zeros(x_sparsity);
output(QP_SOLVER_LAM_A) = DMatrix::zeros(bounds_sparsity);
input_.scheme = SCHEME_QpSolverInput;
output_.scheme = SCHEME_QpSolverOutput;
}
//------------------------------------------------------------------------------
Reverb::Reverb (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, kNumParams) // 1 program, 1 parameter only
{
setNumInputs (kNumInputs); // stereo in
setNumOutputs (kNumOutputs); // stereo out
setUniqueID ('Rvrb'); // identify
canProcessReplacing (); // supports replacing output
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
// internal state var declaration and initialization
fs = getSampleRate();
pcoefs = coefs; // pointer for filter coef assignment
T60LowValue = 3.5; // time, in seconds, for low freqs to decay 60dB
T60LowKnob = SmartKnob::value2knob(T60LowValue, T60LowLimits, T60LowTaper);
T60HighValue = 0.5; // time, in seconds, for high freqs to decay 60dB
T60HighKnob = SmartKnob::value2knob(T60HighValue, T60HighLimits, T60HighTaper);
TransitionValue = 6700.0; // transition freq, in Hz, between low and high freqs
TransitionKnob = SmartKnob::value2knob(TransitionValue, TransitionLimits, TransitionTaper);
WetDryKnob = 0.2; // output (wet/dry) mix
for(int i=0; i<kNumDelays; i++){
dl[i].SetDelay(dlens[i]); // set reverb delay lengths
designShelf(pcoefs,dlens[i], TransitionValue, T60LowValue, T60HighValue); // design filters for feedback loop
fbfilt[i].SetCoefs(coefs); // assign filter coefs
}
ParametricFcValue = 5000.0;
ParametricFcKnob = SmartKnob::value2knob(ParametricFcValue, ParametricFcLimits, ParametricFcTaper);
ParametricGammaValue = dB2mag(0.0);
ParametricGammaKnob = SmartKnob::value2knob(ParametricGammaValue, ParametricGammaLimits, ParametricGammaTaper);
ParametricQValue = 1;
ParametricQKnob = SmartKnob::value2knob(ParametricQValue, ParametricQLimits, ParametricQTaper);
designParametric(parametric_coefs, ParametricFcValue, ParametricGammaValue, ParametricQValue);
parametric[0].setCoefs(parametric_coefs);
parametric[1].setCoefs(parametric_coefs);
}
mdaOverdrive::mdaOverdrive(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 3) // 1 program, 3 parameters
{
fParam1 = 0.0f;
fParam2 = 0.0f;
fParam3 = 0.5f;
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mdaO'); // identify
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Soft Overdrive");
filt1 = filt2 = 0.0f;
setParameter(0, 0.0f);
}
FIR_vst::FIR_vst (audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 1, PORT_COUNT) // 1 program
{
setNumInputs (1); // mono in
setNumOutputs (1); // mono out
setUniqueID ('HGFI'); // identify
canProcessReplacing (); // supports replacing output single precision
//initialize parameters
setParameter(PORT_VOL, 0.5f);
setParameter(PORT_MODEL, 0.5f);
instantiateFIR(&m_State, (uint)getSampleRate());
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
}
//-----------------------------------------------------------------------------------------
tf3Synth::tf3Synth (audioMasterCallback audioMaster, void* hInstance)
: AudioEffectX (audioMaster, kNumPrograms, TF_PARAM_COUNT)
{
// Initialize module path
eChar mpath[512];
eMemSet(mpath, 0, 512);
GetModuleFileName((HMODULE)hInstance, mpath, 512);
eChar *str = &mpath[511];
while (str != mpath && *str!='/' && *str!='\\')
{
*str-- = '\0';
}
modulePath = QString(mpath);
// Initialize tunefish
tf = new tfInstrument();
// initialize programs
for (long i = 0; i < kNumPrograms; i++)
programs[i].loadDefault(i);
loadProgramAll();
for (long i = 0; i < 16; i++)
channelPrograms[i] = i;
if (programs)
setProgram (0);
editor = new tfEditor(this);
if (audioMaster)
{
setNumInputs (0); // no inputs
setNumOutputs (kNumOutputs); // 2 outputs, 1 for each oscillator
canProcessReplacing ();
hasVu (false);
hasClip (false);
isSynth ();
setUniqueID ('TF3'); // <<<! *must* change this!!!!
}
initProcess ();
suspend ();
}
mdaImage::mdaImage(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 6) // programs, parameters
{
fParam1 = 0.6f; //mode
fParam2 = 0.75f; //width
fParam3 = 0.5f; //skew
fParam4 = 0.75f; //centre
fParam5 = 0.5f; //balance
fParam6 = 0.5f; //output
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mdaI'); // identify here
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Stereo Image / MS Matrix");
setParameter(0, 0.6f); //go and set initial values!
}
//-----------------------------------------------------------------------------
MidiGain::MidiGain (audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, kNumPrograms, kNumParams),
programs(0)
{
setNumInputs(2);
setNumOutputs(2);
isSynth();
setUniqueID(PLUG_IDENT);
canProcessReplacing();
programs = new MidiGainProgram[numPrograms];
if (programs)
setProgram (0);
init();
}
ZynWise::ZynWise(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, PROGRAMS_COUNT, kParamsCount)
{
if (audioMaster)
{
isSynth(true);
programsAreChunks(true);
setNumInputs(INPUTS_COUNT);
setNumOutputs(OUTPUTS_COUNT);
setUniqueID(VST_ID);
canProcessReplacing();
View *view = new MainView(this);
view->SetData(&_zasf);
_gui = new Gui(this, GUI_WIDTH, GUI_HEIGHT);
_gui->SetView(view);
setEditor(_gui);
}
}
//-------------------------------------------------------------------------------------------------------
FormantPlugin::FormantPlugin (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1,2) // 1 program, 1 parameter only
{
setNumInputs (2); // stereo in
setNumOutputs (2); // stereo out
setUniqueID ('ijnh'); // identify
canProcessReplacing (); // supports replacing output
canDoubleReplacing (); // supports double precision processing
params[pPosition] = new VstParameter("Position", 1.f);
params[pVowelA] = new VstParameter("VowelA", 1.f);
filters[0]= new StateVariableFilter(800);
filters[1]= new StateVariableFilter(1150);
filters[2]= new StateVariableFilter(800);
filters[3]= new StateVariableFilter(1150);
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
}
mdaSplitter::mdaSplitter(audioMasterCallback audioMaster): AudioEffectX(audioMaster, NPROGS, NPARAMS)
{
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mda7'); ///identify plug-in here
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
env = buf0 = buf1 = buf2 = buf3 = 0.0f;
///differences from default program...
programs[1].param[2] = 0.50f;
programs[1].param[4] = 0.25f;
strcpy(programs[1].name,"Pass Peaks Only");
programs[2].param[0] = 0.60f;
strcpy(programs[2].name,"Stereo Crossover");
setProgram(0);
}
//-------------------------------------------------------------------------------------------------------
Compressor::Compressor (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, 1, kNumParams) // 1 program, 1 parameter only
{
setNumInputs (kNumInputs); // stereo in
setNumOutputs (kNumOutputs); // stereo out
setUniqueID ('Cmpr'); // identify
canProcessReplacing (); // supports replacing output
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
// internal state var declaration and initialization
the_sample_rate=getSampleRate();
InputGainKnob = 0.5;
OutputGainKnob = 0.5;
ThresholdKnob = 0.75;
AttackKnob = 0.0;
ReleaseKnob = 0.125;
RatioKnob = 1.0;
input_gain=pow(10.0,(60.0*InputGainKnob-30.0)/20.0);
output_gain=pow(10.0,(60.0*OutputGainKnob-30.0)/20.0);
threshold=pow(10.0,(30.0*ThresholdKnob-30.0)/20.0);
logthresh=20.0*log10(threshold);
attack_time = pow(10.0,(AttackKnob*3.0-4.0));
attack_amount=1.0-exp(-1.0/(attack_time*the_sample_rate));
release_time = 0.070*pow(10.0,(log10(20.0)*ReleaseKnob));
the_sample_rate=getSampleRate();
release_amount=1.0-exp(-1.0/(release_time*the_sample_rate));
comp_ratio = pow(10.0,(RatioKnob*3.0));
loglev=-96.0;
filtstate=threshold;
gainval=1.0;
dbgainval=0.0;
//memset(past_inputs, 0, num_past_inputs * sizeof(double));
}
mdaSubSynth::mdaSubSynth(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, 1, 6) // programs, parameters
{
//inits here!
fParam1 = (float)0.0; //type
fParam2 = (float)0.3; //level
fParam3 = (float)0.6; //tune
fParam4 = (float)1.0; //dry mix
fParam5 = (float)0.6; //thresh
fParam6 = (float)0.65; //release
setNumInputs(2);
setNumOutputs(2);
setUniqueID("mdaSubSynth"); // identify here
DECLARE_LVZ_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Sub Bass Synthesizer");
resume();
}
//------------------------------------------------------------------------------
WahWah::WahWah (audioMasterCallback audioMaster)
: AudioEffectX (audioMaster, kNumProgs, kNumParams) // 1 program, 1 parameter only
{
setNumInputs (kNumInputs); // stereo in
setNumOutputs (kNumOutputs); // stereo out
setUniqueID ('Dstn'); // identify
canProcessReplacing (); // supports replacing output
vst_strncpy (programName, "Default", kVstMaxProgNameLen); // default program name
GainValue = (float) 0.0; // input filter gain, dB
FcValue = (float) 1000.0; // input filter center frequency, Hz
QValue = (float) 5.0; // input filter resonance, ratio
RateValue = (float) 1.0;
DepthValue = (float) 1.0;
GainKnob = SmartKnob::value2knob(GainValue, GainLimits, GainTaper);
FcKnob = SmartKnob::value2knob(FcValue, FcLimits, FcTaper);
QKnob = SmartKnob::value2knob(QValue, QLimits, QTaper);
RateKnob = (float) SmartKnob::value2knob(RateValue, RateLimits, RateTaper);
DepthKnob = (float) SmartKnob::value2knob(DepthValue, DepthLimits, DepthTaper);
drive = 1.0;
// signal processing parameter and state initialization
fs = getSampleRate(); // sampling rate, Hz
fcSlewer.setTau(.02, fs); // set the mod signal slewer
gSlewer.setTau(.02, fs); // set the mod signal slewer
qSlewer.setTau(.02, fs); // set the mod signal slewer
modSlewer.setTau(.02, fs); // set the mod signal slewer
// place holder
designResonantLowPass(lpCoefs, FcValue, QValue);
lpFilter.setCoefs(lpCoefs);
peak_detector.setTauAttack(0.01, fs);
peak_detector.setTauRelease(0.1, fs);
}
