//------------------------------------------------------------------------
tresult PLUGIN_API AGainSimple::setBusArrangements (SpeakerArrangement* inputs, int32 numIns, SpeakerArrangement* outputs, int32 numOuts)
{
if (numIns == 1 && numOuts == 1)
{
if (inputs[0] == SpeakerArr::kMono && outputs[0] == SpeakerArr::kMono)
{
AudioBus* bus = FCast<AudioBus> (audioInputs.at (0));
if (bus)
{
if (bus->getArrangement () != SpeakerArr::kMono)
{
removeAudioBusses ();
addAudioInput (USTRING ("Mono In"), SpeakerArr::kMono);
addAudioOutput (USTRING ("Mono Out"), SpeakerArr::kMono);
}
return kResultOk;
}
}
else
{
AudioBus* bus = FCast<AudioBus> (audioInputs.at (0));
if (bus)
{
if (bus->getArrangement () != SpeakerArr::kStereo)
{
removeAudioBusses ();
addAudioInput (USTRING ("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING ("Stereo Out"), SpeakerArr::kStereo);
}
return kResultOk;
}
}
}
return kResultFalse;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API MultiBandProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = 1.00; //Listen: L/M/H/out
params[1] = 0.103; //xover1
params[2] = 0.878; //xover2
params[3] = 0.54; //L drive (1)
params[4] = 0.00; //M drive
params[5] = 0.60; //H drive
params[6] = 0.45; //L trim (2)
params[7] = 0.50; //M trim
params[8] = 0.50; //H trim
params[9] = 0.22; //attack (3)
params[10] = 0.602; //release (4)
params[11] = 0.55; //width
params[12] = 0.; //MS swap
fb1 = fb2 = fb3 = 0.f;
gain1 = gain2 = gain3 = 0.f;
recalculate ();
}
return res;
}
IoValue *IoObject_catchException(IoObject *self, IoObject *locals, IoMessage *m)
{
IoValue *result;
IoMessage_assertArgCount_(m, 3);
{
IoString *exceptionName = (IoString *)IoMessage_locals_stringArgAt_(m, locals, 0);
IoExceptionCatch *eCatch = IoState_pushExceptionCatchWithName_((IoState*)self->tag->state,
CSTRING(exceptionName));
TInt r = 0;
TRAP(r, result = (IoValue*)IoMessage_locals_valueArgAt_(m, locals, 1);
IoState_popExceptionCatch_((IoState*)self->tag->state, eCatch););
if(r != 0)
{
IoObject_setSlot_to_((IoObject*)locals, USTRING("exceptionName"), eCatch->caughtName);
if (eCatch->caughtDescription)
{
IoObject_setSlot_to_(locals, USTRING("exceptionDescription"),
eCatch->caughtDescription);
}
else
{
IoObject_setSlot_to_(locals, USTRING("exceptionDescription"),
USTRING("<no description>"));
}
IoState_popExceptionCatch_((IoState*)self->tag->state, eCatch);
result = (IoValue*)IoMessage_locals_valueArgAt_(m, locals, 2);
}
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API AmbienceProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
//inits here!
params[0] = 0.7; //size
params[1] = 0.7; //hf
params[2] = 0.9; //mix
params[3] = 0.5; //output
buf1 = new float[1024];
buf2 = new float[1024];
buf3 = new float[1024];
buf4 = new float[1024];
fil = 0.0f;
den = pos = 0;
recalculate ();
}
return res;
}
tresult PLUGIN_API IPlugVST3Plugin::setBusArrangements(SpeakerArrangement* inputs, int32 numIns, SpeakerArrangement* outputs, int32 numOuts)
{
TRACE;
// disconnect all io pins, they will be reconnected in process
SetInputChannelConnections(0, NInChannels(), false);
SetOutputChannelConnections(0, NOutChannels(), false);
int32 reqNumInputChannels = SpeakerArr::getChannelCount(inputs[0]); //requested # input channels
int32 reqNumOutputChannels = SpeakerArr::getChannelCount(outputs[0]);//requested # output channels
// legal io doesn't consider sidechain inputs
if (!LegalIO(reqNumInputChannels, reqNumOutputChannels))
{
return kResultFalse;
}
// handle input
AudioBus* bus = FCast<AudioBus>(audioInputs.at(0));
// if existing input bus has a different number of channels to the input bus being connected
if (bus && SpeakerArr::getChannelCount(bus->getArrangement()) != reqNumInputChannels)
{
audioInputs.remove(bus);
addAudioInput(USTRING("Input"), getSpeakerArrForChans(reqNumInputChannels));
}
// handle output
bus = FCast<AudioBus>(audioOutputs.at(0));
// if existing output bus has a different number of channels to the output bus being connected
if (bus && SpeakerArr::getChannelCount(bus->getArrangement()) != reqNumOutputChannels)
{
audioOutputs.remove(bus);
addAudioOutput(USTRING("Output"), getSpeakerArrForChans(reqNumOutputChannels));
}
if (!mScChans && numIns == 1) // No sidechain, every thing OK
{
return kResultTrue;
}
if (mScChans && numIns == 2) // numIns = num Input BUSes
{
int32 reqNumSideChainChannels = SpeakerArr::getChannelCount(inputs[1]); //requested # sidechain input channels
bus = FCast<AudioBus>(audioInputs.at(1));
if (bus && SpeakerArr::getChannelCount(bus->getArrangement()) != reqNumSideChainChannels)
{
audioInputs.remove(bus);
addAudioInput(USTRING("Sidechain Input"), getSpeakerArrForChans(reqNumSideChainChannels), kAux, 0); // either mono or stereo
}
return kResultTrue;
}
return kResultFalse;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API OverdriveProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = 0.0f;
params[1] = 0.0f;
params[2] = 0.5f;
recalculate ();
}
return res;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API DetuneController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
parameters.addParameter (USTRING("Detune"), USTRING("cents"), 0, 0.4, ParameterInfo::kCanAutomate, kParam0);
parameters.addParameter (new ScaledParameter (USTRING("Mix"), USTRING("%"), 0, 0.4, ParameterInfo::kCanAutomate, kParam1, 0, 99));
parameters.addParameter (new ScaledParameter (USTRING("Output"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, kParam2, -20, 20));
parameters.addParameter (USTRING("Latency"), USTRING("ms"), 0, 0.5, ParameterInfo::kCanAutomate, kParam3);
}
return res;
}
//------------------------------------------------------------------------
tresult PLUGIN_API AGainSimple::initialize (FUnknown* context)
{
tresult result = SingleComponentEffect::initialize (context);
if (result != kResultOk)
return result;
//---create Audio In/Out buses------
// we want a stereo Input and a Stereo Output
addAudioInput (USTRING ("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING ("Stereo Out"), SpeakerArr::kStereo);
//---create MIDI In/Out buses (1 bus with only 1 channel)------
addEventInput (USTRING ("MIDI In"), 1);
//---Create Parameters------------
//---Gain parameter--
GainParameter* gainParam = new GainParameter (ParameterInfo::kCanAutomate, kGainId);
parameters.addParameter (gainParam);
//---VuMeter parameter---
int32 stepCount = 0;
ParamValue defaultVal = 0;
int32 flags = ParameterInfo::kIsReadOnly;
int32 tag = kVuPPMId;
parameters.addParameter (USTRING ("VuPPM"), 0, stepCount, defaultVal, flags, tag);
//---Bypass parameter---
stepCount = 1;
defaultVal = 0;
flags = ParameterInfo::kCanAutomate|ParameterInfo::kIsBypass;
tag = kBypassId;
parameters.addParameter (USTRING ("Bypass"), 0, stepCount, defaultVal, flags, tag);
//---Custom state init------------
UString str (defaultMessageText, 128);
str.fromAscii ("Hello World!");
return result;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API RingModProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = (float)0.0625; //1kHz
params[1] = (float)0.0;
params[2] = (float)0.0;
fPhi = 0.0;
twoPi = (float)6.2831853;
fprev = 0.f;
recalculate ();
}
return res;
}
IoValue *IoSocket_waitForReadLine(IoSocket *self, IoValue *locals, IoMessage *m)
{
IoState* state = (IoState*)self->tag->state;
while(!self->lineRead)
{
IoState_yield(state);
}
IoValue* value = (IoValue*)USTRING(self->lineRead);
free(self->lineRead);
self->lineRead = 0;
return (IoValue*)value;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API TestToneProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = 0.47f; //mode
params[1] = 0.71f; //level dB
params[2] = 0.50f; //pan dB
params[3] = 0.57f; //freq1 B
params[4] = 0.50f; //freq2 Hz
params[5] = 0.00f; //thru dB
params[6] = 0.30f; //sweep ms
params[7] = 1.00f; //cal dBFS
recalculate ();
}
return res;
}
//-----------------------------------------------------------------------------
// member function of PluginController!
// define parameter definitions here...
tresult PLUGIN_API Instrument::initialize (FUnknown* context){
parameters.addParameter(new RangeParameter(STR16("Gain"), kGainId, STR16("dB"), -100, 0, GAIN_DEFAULT_DB));
parameters.addParameter(new RangeParameter(STR16("Attack"), kAttackId, STR16("ms"), 0, 1000, ATTACK_DEFAULT_MS));
parameters.addParameter(new RangeParameter(STR16("Decay"), kDecayId, STR16("ms"),0, 1000, DECAY_DEFAULT_MS));
parameters.addParameter(new RangeParameter(STR16("Sustain Rate"), kSustainRateId, STR16("%"), 0, 100, SUSTAINRATE_DEFAULT));
parameters.addParameter(new RangeParameter(STR16("Release"), kReleaseId, STR16("ms"), 0, 1000, RELEASE_DEFAULT_MS));
// StringlistParameter fuer Auswahl von Waveform
StringListParameter* stringListParameter = new StringListParameter(STR16("Waveform"), kWaveTypeId);
stringListParameter->appendString(USTRING("Sinus"));
stringListParameter->appendString(USTRING("Sawtooth"));
stringListParameter->appendString(USTRING("Squarewave"));
stringListParameter->appendString(USTRING("Triangle"));
parameters.addParameter(stringListParameter);
parameters.addParameter(new RangeParameter(STR16("PWM"), kPWMId, STR16("%"), 0, 100, PWM_DEFAULT_PERCENTAGE));
parameters.addParameter(new RangeParameter(STR16("PWM LFO"), kLFO_PWM_freqId, STR16("Hz"), 0, 10, LFO_PWM_FREQ_DEFAULT_VALUE));
parameters.addParameter(new RangeParameter(STR16("CutOff"), kCutOffId, STR16("Hz"), 20, 20000, CUTOFF_DEFAULT_FREQUENCY));
parameters.addParameter(new RangeParameter(STR16("Resonance"), kResId, STR16("%"), 100, 0, RESONANCE_DEFAULT_VALUE));
parameters.addParameter(new RangeParameter(STR16("Autopan Freq"), kLFO_autopan_freqId, STR16("Hz"), 0, 15, LFO_AUTOPAN_FREQ_DEFAULT_VALUE));
parameters.addParameter(new RangeParameter(STR16("Autopan Phase"), kLFO_autopan_phaseId, STR16("%"), 0, 100, LFO_AUTOPAN_PHASE_DEFAULT_VALUE));
// fix for RangeParameter (default value is not yet set)
for(int i = 0; i < parameters.getParameterCount(); i++){
Parameter* p = parameters.getParameterByIndex(i);
p->setNormalized(p->getInfo().defaultNormalizedValue);
}
// SET Parameters ON STARTUP
// GAIN
float dB = 20 * log(DEFAULTGAIN);
processor.setGain(dB);
processor.setCutOff(CUTOFF_DEFAULT_FREQUENCY);
processor.setRes(1.4f);
processor.setCutOff(CUTOFF_DEFAULT_FREQUENCY);
processor.setSustainRate(SUSTAINRATE_DEFAULT);
return InstrumentAdapter::initialize(context);
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API TalkBoxController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
ParamID pid = 0;
parameters.addParameter (USTRING("Wet"), USTRING(""), 0, 0.15, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Dry"), USTRING(""), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
IndexedParameter* carrierParam = new IndexedParameter (USTRING("Carrier"), USTRING(""), 1, 0.5, ParameterInfo::kCanAutomate | ParameterInfo::kIsList, pid++);
carrierParam->setIndexString (0, UString128("RIGHT"));
carrierParam->setIndexString (1, UString128("LEFT"));
parameters.addParameter (carrierParam);
parameters.addParameter (USTRING("Quality"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
}
return res;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API DynamicsProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = 0.60; //thresh ///Note : special version for ardislarge
params[1] = 0.40; //ratio
params[2] = 0.10; //level ///was 0.6
params[3] = 0.18; //attack
params[4] = 0.55; //release
params[5] = 1.00; //Limiter
params[6] = 0.00; //gate thresh
params[7] = 0.10; //gate attack
params[8] = 0.50; //gate decay
params[9] = 1.00; //fx mix
recalculate ();
}
return res;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API RezFilterProcessor::initialize (FUnknown* context)
{
tresult res = BaseProcessor::initialize (context);
if (res == kResultTrue)
{
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo Out"), SpeakerArr::kStereo);
params[0] = 0.33f; //f
params[1] = 0.70f; //q
params[2] = 0.50f; //a
params[3] = 0.85f; //fenv
params[4] = 0.00f; //att
params[5] = 0.50f; //rel
params[6] = 0.70f; //lfo
params[7] = 0.40f; //rate
params[8] = 0.00f; //trigger
params[9] = 0.75f; //max freq
recalculate ();
}
return res;
}
IoValue *IoSocket_read(IoSocket *self, IoValue *locals, IoMessage *m)
{
IoNumber *size = (IoNumber*)IoMessage_locals_numberArgAt_(m, locals, 0);
IoState* state = (IoState*)self->tag->state;
int trueSize = IoNumber_asInt(size);
char* buffer = (char*)malloc(trueSize + 1);
memset(buffer, 0, trueSize + 1);
TInt status = self->socket->ReadOneOrMore(buffer, trueSize);
if(status != 0)
{
IoState_error_description_(state, "IoSocket.read", "RSocket.Read: '%d'\n", status);
}
IoValue* result = (IoValue*)USTRING(buffer);
free(buffer);
return result;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API OverdriveController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
ParamID pid = 0;
parameters.addParameter (new ScaledParameter (USTRING("Drive"), USTRING("%"), 0, 0.15, ParameterInfo::kCanAutomate, pid++, 0, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Muffle"), USTRING("%"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, 0, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Output"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
}
return res;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API ShepardController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
ParamID pid = 0;
IndexedParameter* modeParam = new IndexedParameter (USTRING("Mode"), USTRING(""), 2, 0.15, ParameterInfo::kCanAutomate | ParameterInfo::kIsList, pid++);
modeParam->setIndexString (0, UString128("TONES"));
modeParam->setIndexString (1, UString128("RING MOD"));
modeParam->setIndexString (2, UString128("TONES+IN"));
parameters.addParameter (modeParam);
parameters.addParameter (new ScaledParameter (USTRING("Rate"), USTRING("%"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, -100, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Output"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
}
return res;
}
IoValue *IoSocket_readLine(IoSocket *self, IoValue *locals, IoMessage *m)
{
IoNumber *size = (IoNumber*)IoMessage_locals_numberArgAt_(m, locals, 0);
IoState* state = (IoState*)self->tag->state;
if(self->activeReadLine)
{
delete self->activeReadLine;
self->activeReadLine = 0;
}
int trueSize = IoNumber_asInt(size);
char* buffer = (char*)malloc(trueSize + 1);
memset(buffer, 0, trueSize + 1);
self->activeReadLine = CReadLineSocket::NewL(self->socket, self, buffer, trueSize);
self->activeReadLine->StartReadLineL();
while(!self->lineRead)
{
IoState_yield(state);
}
IoValue* value = (IoValue*)USTRING(self->lineRead);
free(self->lineRead);
self->lineRead = 0;
return (IoValue*)value;
}
IoValue *IoSocket_getLineRead(IoSocket *self, IoValue *locals, IoMessage *m)
{
return (IoValue*)USTRING(self->lineRead);
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API RezFilterController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
ParamID pid = 0;
parameters.addParameter (new ScaledParameter (USTRING("Freq"), USTRING("%"), 0, 0.15, ParameterInfo::kCanAutomate, pid++, 0, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Res"), USTRING("%"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, 0, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Output"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
parameters.addParameter (new ScaledParameter (USTRING("Env->VCF"), USTRING("%"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, -100, 100, true));
parameters.addParameter (USTRING("Attack"), USTRING("ms"), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Release"), USTRING("ms"), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (new ScaledParameter (USTRING("LFO->VCF"), USTRING("S+H<>Sin"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, -100, 100, true));
parameters.addParameter (USTRING("LFO Rate"), USTRING("Hz"), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Trigger"), USTRING("dB"), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (new ScaledParameter (USTRING("Max Freq"), USTRING("%"), 0, 0.6, ParameterInfo::kCanAutomate, pid++, 0, 100, true));
}
return res;
}
IoValue *IoSocket_host(IoSocket *self, IoValue *locals, IoMessage *m)
{
return (IoValue *)USTRING(self->host);
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API ComboController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
IndexedParameter* modelParam = new IndexedParameter (USTRING("Model"), 0, 6, 0.7, ParameterInfo::kCanAutomate | ParameterInfo::kIsList, kParam0);
modelParam->setIndexString (0, UString128("D.I."));
modelParam->setIndexString (1, UString128("Spkr Sim"));
modelParam->setIndexString (2, UString128("Radio"));
modelParam->setIndexString (3, UString128("MB 1\""));
modelParam->setIndexString (4, UString128("MB 8\""));
modelParam->setIndexString (5, UString128("4x12 ^"));
modelParam->setIndexString (6, UString128("4x12 >"));
parameters.addParameter (modelParam);
parameters.addParameter (new ScaledParameter (USTRING("Drive"), USTRING("S <> H"), 0, 0.7, ParameterInfo::kCanAutomate, kParam1, -100, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Bias"), 0, 0, 0.9, ParameterInfo::kCanAutomate, kParam2, -100, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("Output"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, kParam3, -20, 20, true));
IndexedParameter* modeParam = new IndexedParameter (USTRING("Process"), 0, 1, 0.5, ParameterInfo::kCanAutomate | ParameterInfo::kIsList, kParam4);
modeParam->setIndexString (0, UString128("Stereo"));
modeParam->setIndexString (1, UString128("Mono"));
parameters.addParameter (modeParam);
parameters.addParameter (new ScaledParameter (USTRING("HPF Freq"), USTRING("%"), 0, 0.5, ParameterInfo::kCanAutomate, kParam5, 0, 100, true));
parameters.addParameter (new ScaledParameter (USTRING("HPF Reso"), USTRING("%"), 0, 0.5, ParameterInfo::kCanAutomate, kParam6, 0, 100, true));
}
return res;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API MultiBandController::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
ParamID pid = 0;
IndexedParameter* listenParam = new IndexedParameter (USTRING("Listen"), USTRING(""), 3, 0., ParameterInfo::kCanAutomate | ParameterInfo::kIsList, pid++);
listenParam->setIndexString (0, UString128("Low"));
listenParam->setIndexString (1, UString128("Mid"));
listenParam->setIndexString (2, UString128("High"));
listenParam->setIndexString (3, UString128("Output"));
parameters.addParameter (listenParam);
parameters.addParameter (USTRING("L <> M"), USTRING("Hz"), 0, 0.15, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("M <> H"), USTRING("Hz"), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (new ScaledParameter (USTRING("L Comp"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, 0, 30, true));
parameters.addParameter (new ScaledParameter (USTRING("M Comp"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, 0, 30, true));
parameters.addParameter (new ScaledParameter (USTRING("H Comp"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, 0, 30, true));
parameters.addParameter (new ScaledParameter (USTRING("L Out"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
parameters.addParameter (new ScaledParameter (USTRING("M Out"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
parameters.addParameter (new ScaledParameter (USTRING("H Out"), USTRING("dB"), 0, 0.5, ParameterInfo::kCanAutomate, pid++, -20, 20, true));
parameters.addParameter (USTRING("Attack"), UString128(kMicroSecondsString), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Release"), USTRING("ms"), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Stereo Width"), USTRING("%"), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Stereo"), USTRING(""), 1, 0.5, ParameterInfo::kCanAutomate, pid++);
}
return res;
}
tresult PLUGIN_API IPlugVST3::setBusArrangements(SpeakerArrangement* inputs, int32 numIns, SpeakerArrangement* outputs, int32 numOuts)
{
TRACE;
//inputs
AudioBus* bus = getAudioInput(0);
if (bus && bus->getArrangement() != inputs[0])
{
if (inputs[0] == SpeakerArr::kMono)
{
//re-create the busses..
audioInputs.remove(bus);
if (mScChans)
{
bus = getAudioInput(0);
if (bus && bus->getArrangement() != inputs[1]) //sidechain SpeakerArr:: must match the input SpeakerArr::
{
audioInputs.remove(bus);
}
}
addAudioInput(USTRING ("Mono In"), SpeakerArr::kMono);
addAudioInput(USTRING ("Mono Sidechain In"), SpeakerArr::kMono, kAux, 0);
//disconnect the unused pins, don't worry about sidechain yet - it will get done at process()
SetInputChannelConnections(1, NInChannels(), false);
mSideChainIsConnected = false;
}
}
//outputs
bus = getAudioOutput(0);
if (bus && bus->getArrangement() != outputs[0])
{
if (outputs[0] == SpeakerArr::kMono)
{
audioOutputs.remove(bus);
addAudioOutput(USTRING ("Mono Out"), SpeakerArr::kMono);
//disconnect the unused pin
SetOutputChannelConnections(1, NOutChannels(), false);
}
}
if (mScChans)
{
if (getAudioInput(0)->getArrangement() == inputs[0] &&
getAudioOutput(0)->getArrangement() == outputs[0] &&
getAudioInput(1)->getArrangement() == inputs[1])
return kResultOk;
}
else
{
if (getAudioInput(0)->getArrangement() == inputs[0] &&
getAudioOutput(0)->getArrangement() == outputs[0])
return kResultOk;
}
return kResultFalse;
}
tresult PLUGIN_API TripleFProcessor::initialize(FUnknown *context)
{
tresult initbase = AudioEffect::initialize(context);
if(initbase == kResultTrue)
{
if(removeAllBusses() != kResultTrue)
return kResultFalse;
addAudioInput (USTRING("Stereo In"), SpeakerArr::kStereo);
addAudioOutput (USTRING("Stereo out"), SpeakerArr::kStereo);
try
{
m_env = new OpenCLEnvironment(CL_DEVICE_TYPE_GPU);
m_compiler = new Compiler(*m_env, path("%FFF%/cl").getPath());
m_compiler->build();
WaveReader<Sample> hReader("h.wav");
UInt channelCount = hReader.getChannelCount();
UInt sampleCount = hReader.getSampleCount();
m_ssize = sampleCount - 1;
ComputingData<Sample> cd(sampleCount);
DeviceProperties devprops(m_env->getDevice());
Mapper map(cd, devprops, 0);
m_x = new mcf::hmcp;
m_y = new mcf::hmcp;
mcf::multichannel b, a;
mcf::create(b, *m_env, CL_MEM_READ_ONLY, channelCount, fff_POW2(map.getLb2N()));
mcf::create(a, *m_env, CL_MEM_READ_ONLY, channelCount, fff_POW2(map.getLb2N()));
for(UInt ch = 0; ch < channelCount; ++ch)
a.host->getRawReal(ch)[0] = (Sample)20.f;
mcf::create(m_H, *m_env, CL_MEM_READ_WRITE, channelCount, fff_POW2(map.getLb2N()));
hReader.readFile(*(b.host));
TransferFunction<Sample> tra(*m_compiler, *b, *a, *m_H);
tra.invokeAndWait();
}
catch(...)
{
initbase = kResultFalse;
}
}
return
initbase;
}
//-----------------------------------------------------------------------------
tresult PLUGIN_API JX10Controller::initialize (FUnknown* context)
{
tresult res = BaseController::initialize (context);
if (res == kResultTrue)
{
IndexedParameter* presetParam = new IndexedParameter (USTRING("Factory Presets"), USTRING("%"), JX10Processor::kNumPrograms-1, 0, ParameterInfo::kIsProgramChange | ParameterInfo::kCanAutomate | ParameterInfo::kIsList, kPresetParam);
parameters.addParameter (presetParam);
ParamID pid = 0;
parameters.addParameter (USTRING("OSC Mix"), USTRING(""), 0, 0.15, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("OSC Tune"), USTRING(""), 0, 0.6, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("OSC Fine"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
IndexedParameter* glideModeParam = new IndexedParameter (USTRING("Glide"), 0, 5, 0, ParameterInfo::kCanAutomate | ParameterInfo::kIsList, pid++);
glideModeParam->setIndexString (0, UString128("Poly"));
glideModeParam->setIndexString (1, UString128("Poly-Legato"));
glideModeParam->setIndexString (2, UString128("Poly-Glide"));
glideModeParam->setIndexString (3, UString128("Mono"));
glideModeParam->setIndexString (4, UString128("Mono-Legato"));
glideModeParam->setIndexString (5, UString128("Mono-Glide"));
parameters.addParameter (glideModeParam);
parameters.addParameter (USTRING("Gld Rate"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Gld Bend"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Freq"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Reso"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Env"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF LFO"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Vel"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Att"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Dec"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Sus"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("VCF Rel"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("ENV Att"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("ENV Dec"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("ENV Sus"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("ENV Rel"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("LFO Rate"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Vibrato"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Noise"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Octave"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
parameters.addParameter (USTRING("Tuning"), USTRING(""), 0, 0.5, ParameterInfo::kCanAutomate, pid++);
midiCCParamID[kCtrlModWheel] = kModWheelParam;
parameters.addParameter (USTRING("Mod Wheel"), USTRING(""), 0, 0, 0, kModWheelParam);
midiCCParamID[kPitchBend] = kPitchBendParam;
parameters.addParameter (USTRING("Pitch Bend"), USTRING(""), 0, 0, 0.5, kPitchBendParam);
midiCCParamID[kCtrlBreath] = kBreathParam;
midiCCParamID[kCtrlFilterResonance] = kBreathParam;
parameters.addParameter (USTRING("Filter Mod+"), USTRING(""), 0, 0, 0.5, kBreathParam);
midiCCParamID[3] = kCtrler3Param;
parameters.addParameter (USTRING("Filter Mod-"), USTRING(""), 0, 0, 0.5, kCtrler3Param);
midiCCParamID[kCtrlExpression] = kCtrler3Param;
parameters.addParameter (USTRING("Filter Resonance"), USTRING(""), 0, 0, 0.5, kExpressionParam);
midiCCParamID[kAfterTouch] = kAftertouchParam;
parameters.addParameter (USTRING("Aftertouch"), USTRING(""), 0, 0, 0.5, kAftertouchParam);
int32 i = 0;
presetParam->setIndexString (i++, UString128("5th Sweep Pad"));
presetParam->setIndexString (i++, UString128("Echo Pad [SA]"));
presetParam->setIndexString (i++, UString128("Space Chimes [SA]"));
presetParam->setIndexString (i++, UString128("Solid Backing"));
presetParam->setIndexString (i++, UString128("Velocity Backing [SA]"));
presetParam->setIndexString (i++, UString128("Rubber Backing [ZF]"));
presetParam->setIndexString (i++, UString128("808 State Lead"));
presetParam->setIndexString (i++, UString128("Mono Glide"));
presetParam->setIndexString (i++, UString128("Detuned Techno Lead"));
presetParam->setIndexString (i++, UString128("Hard Lead [SA]"));
presetParam->setIndexString (i++, UString128("Bubble"));
presetParam->setIndexString (i++, UString128("Monosynth"));
presetParam->setIndexString (i++, UString128("Moogcury Lite"));
presetParam->setIndexString (i++, UString128("Gangsta Whine"));
presetParam->setIndexString (i++, UString128("Higher Synth [ZF]"));
presetParam->setIndexString (i++, UString128("303 Saw Bass"));
presetParam->setIndexString (i++, UString128("303 Square Bass"));
presetParam->setIndexString (i++, UString128("Analog Bass"));
presetParam->setIndexString (i++, UString128("Analog Bass 2"));
presetParam->setIndexString (i++, UString128("Low Pulses"));
presetParam->setIndexString (i++, UString128("Sine Infra-Bass"));
presetParam->setIndexString (i++, UString128("Wobble Bass [SA]"));
presetParam->setIndexString (i++, UString128("Squelch Bass"));
presetParam->setIndexString (i++, UString128("Rubber Bass [ZF]"));
presetParam->setIndexString (i++, UString128("Soft Pick Bass"));
presetParam->setIndexString (i++, UString128("Fretless Bass"));
presetParam->setIndexString (i++, UString128("Whistler"));
presetParam->setIndexString (i++, UString128("Very Soft Pad"));
presetParam->setIndexString (i++, UString128("Pizzicato"));
presetParam->setIndexString (i++, UString128("Synth Strings"));
presetParam->setIndexString (i++, UString128("Synth Strings 2"));
presetParam->setIndexString (i++, UString128("Leslie Organ"));
presetParam->setIndexString (i++, UString128("Click Organ"));
presetParam->setIndexString (i++, UString128("Hard Organ"));
presetParam->setIndexString (i++, UString128("Bass Clarinet"));
presetParam->setIndexString (i++, UString128("Trumpet"));
presetParam->setIndexString (i++, UString128("Soft Horn"));
presetParam->setIndexString (i++, UString128("Brass Section"));
presetParam->setIndexString (i++, UString128("Synth Brass"));
presetParam->setIndexString (i++, UString128("Detuned Syn Brass [ZF]"));
presetParam->setIndexString (i++, UString128("Power PWM"));
presetParam->setIndexString (i++, UString128("Water Velocity [SA]"));
presetParam->setIndexString (i++, UString128("Ghost [SA]"));
presetParam->setIndexString (i++, UString128("Soft E.Piano"));
presetParam->setIndexString (i++, UString128("Thumb Piano"));
presetParam->setIndexString (i++, UString128("Steel Drums [ZF]"));
presetParam->setIndexString (i++, UString128("Car Horn"));
presetParam->setIndexString (i++, UString128("Helicopter"));
presetParam->setIndexString (i++, UString128("Arctic Wind"));
presetParam->setIndexString (i++, UString128("Thip"));
presetParam->setIndexString (i++, UString128("Synth Tom"));
presetParam->setIndexString (i++, UString128("Squelchy Frog"));
}
return res;
}
//-----------------------------------------------------------------------------
// member function of PluginController!
// define parameter definitions here...
void PluginController::setupParameters(){
/*------------------Low Band Parameters----------------------------*/
// Filter Type
StringListParameter* stringListParameter = new StringListParameter(STR16("Typ_low"), kFilterTypeLowId);
stringListParameter->appendString(USTRING("Peak"));
stringListParameter->appendString(USTRING("Lowpass"));
stringListParameter->appendString(USTRING("Highpass"));
stringListParameter->appendString(USTRING("Low Shelf"));
stringListParameter->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter);
// low Frequenz: 20...200 Hz
parameters.addParameter(new RangeParameter(STR16("Frequency_low"), kFrequencyLowId, STR16("Hz"), MINFREQ_low, MAXFREQ_low, 1));
// low Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_low"), kQLowId, STR16("Hz"), 0.1, MAXQ));
// low Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_low"), kGainLowId, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
// low Bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_low"), kBypassLowId, STR16(""), false, true, 1));
/*------------------Mid Band 1 Parameters ------------------------*/
StringListParameter* stringListParameter_mid1 = new StringListParameter(STR16("Typ_mid1"), kFilterTypeMid1Id);
stringListParameter_mid1->appendString(USTRING("Peak"));
stringListParameter_mid1->appendString(USTRING("Lowpass"));
stringListParameter_mid1->appendString(USTRING("Highpass"));
stringListParameter_mid1->appendString(USTRING("Low Shelf"));
stringListParameter_mid1->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter_mid1);
// mid1 Frequenz:
parameters.addParameter(new RangeParameter(STR16("Frequency_mid1"), kFrequencyMid1Id, STR16("Hz"), MINFREQ_mid1, MAXFREQ_mid1));
// mid1 Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_mid1"), kQMid1Id, STR16("Hz"), 0.1, MAXQ));
// mid1 Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_mid1"), kGainMid1Id, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
//bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_mid1"), kBypassMid1Id, STR16(""), false, true, 1));
/*------------------Mid Band 2 Parameters ------------------------*/
StringListParameter* stringListParameter_mid2 = new StringListParameter(STR16("Typ_mid2"), kFilterTypeMid2Id);
stringListParameter_mid2->appendString(USTRING("Peak"));
stringListParameter_mid2->appendString(USTRING("Lowpass"));
stringListParameter_mid2->appendString(USTRING("Highpass"));
stringListParameter_mid2->appendString(USTRING("Low Shelf"));
stringListParameter_mid2->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter_mid2);
// mid2 Frequenz:
parameters.addParameter(new RangeParameter(STR16("Frequency_mid2"), kFrequencyMid2Id, STR16("Hz"), MINFREQ_mid2, MAXFREQ_mid2, (MINFREQ_mid2 + MAXFREQ_mid2)/2));
// mid2 Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_mid2"), kQMid2Id, STR16("Hz"), 0.1, MAXQ));
// mid2 Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_mid2"), kGainMid2Id, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
//bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_mid2"), kBypassMid2Id, STR16(""), false, true, 1));
/*------------------Mid Band 3 Parameters ------------------------*/
StringListParameter* stringListParameter_mid3 = new StringListParameter(STR16("Typ_mid3"), kFilterTypeMid3Id);
stringListParameter_mid3->appendString(USTRING("Peak"));
stringListParameter_mid3->appendString(USTRING("Lowpass"));
stringListParameter_mid3->appendString(USTRING("Highpass"));
stringListParameter_mid3->appendString(USTRING("Low Shelf"));
stringListParameter_mid3->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter_mid3);
// mid3 Frequenz:
parameters.addParameter(new RangeParameter(STR16("Frequency_mid3"), kFrequencyMid3Id, STR16("Hz"), MINFREQ_mid3, MAXFREQ_mid3, (MINFREQ_mid3 + MAXFREQ_mid3)/2));
// mid3 Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_mid3"), kQMid3Id, STR16("Hz"), 0.1, MAXQ));
// mid3 Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_mid3"), kGainMid3Id, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
//bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_mid3"), kBypassMid3Id, STR16(""), false, true, 1));
/*------------------Mid Band 4 Parameters ------------------------*/
StringListParameter* stringListParameter_mid4 = new StringListParameter(STR16("Typ_mid4"), kFilterTypeMid4Id);
stringListParameter_mid4->appendString(USTRING("Peak"));
stringListParameter_mid4->appendString(USTRING("Lowpass"));
stringListParameter_mid4->appendString(USTRING("Highpass"));
stringListParameter_mid4->appendString(USTRING("Low Shelf"));
stringListParameter_mid4->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter_mid4);
// mid4 Frequenz:
parameters.addParameter(new RangeParameter(STR16("Frequency_mid4"), kFrequencyMid4Id, STR16("Hz"), MINFREQ_mid4, MAXFREQ_mid4, (MINFREQ_mid4 + MAXFREQ_mid4)/2));
// mid4 Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_mid4"), kQMid4Id, STR16("Hz"), 0.1, MAXQ));
// mid4 Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_mid4"), kGainMid4Id, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
//bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_mid4"), kBypassMid4Id, STR16(""), false, true, 1));
/*------------------ High Band Parameters-------------------------*/
// Filter Type
StringListParameter* stringListParameter_high = new StringListParameter(STR16("Typ_high"), kFilterTypeHighId);
stringListParameter_high->appendString(USTRING("Peak"));
stringListParameter_high->appendString(USTRING("Lowpass"));
stringListParameter_high->appendString(USTRING("Highpass"));
stringListParameter_high->appendString(USTRING("Low Shelf"));
stringListParameter_high->appendString(USTRING("High Shelf"));
parameters.addParameter(stringListParameter_high);
// high Frequenz: 2500...18000 Hz
parameters.addParameter(new RangeParameter(STR16("Frequency_high"), kFrequencyHighId, STR16("Hz"), MINFREQ_high, MAXFREQ_high));
// high Q: 0,1 ... 18
parameters.addParameter(new RangeParameter(STR16("Q_high"), kQHighId, STR16("Hz"), 0.1, MAXQ));
// high Gain: -24 dB ... +24 dB
parameters.addParameter(new RangeParameter(STR16("Gain_high"), kGainHighId, STR16("dB"), -MAXGAIN, MAXGAIN, 0));
//bypass
parameters.addParameter(new RangeParameter(STR16("Bypass_high"), kBypassHighId, STR16(""), false, true, 1));
}
