// We're only ever playing one note (monophonic)
void Arponaut::NoteOff()
{
if (playing_.StatusMsg() != IMidiMsg::kNoteOff) {
IMidiMsg offMsg;
offMsg.MakeNoteOffMsg(playing_.NoteNumber(), playing_.mOffset);
SendMidiMsg(&offMsg);
playing_ = offMsg;
}
}
void Synthesis::processVirtualKeyboard() {
IKeyboardControl* virtualKeyboard = (IKeyboardControl*) mVirtualKeyboard;
int virtualKeyboardNoteNumber = virtualKeyboard->GetKey() + virtualKeyboardMinimumNoteNumber;
if(lastVirtualKeyboardNoteNumber >= virtualKeyboardMinimumNoteNumber && virtualKeyboardNoteNumber != lastVirtualKeyboardNoteNumber) {
// The note number has changed from a valid key to something else (valid key or nothing). Release the valid key:
IMidiMsg midiMessage;
midiMessage.MakeNoteOffMsg(lastVirtualKeyboardNoteNumber, 0);
mMIDIReceiver.onMessageReceived(&midiMessage);
}
if (virtualKeyboardNoteNumber >= virtualKeyboardMinimumNoteNumber && virtualKeyboardNoteNumber != lastVirtualKeyboardNoteNumber) {
// A valid key is pressed that wasn't pressed the previous call. Send a "note on" message to the MIDI receiver:
IMidiMsg midiMessage;
midiMessage.MakeNoteOnMsg(virtualKeyboardNoteNumber, virtualKeyboard->GetVelocity(), 0);
mMIDIReceiver.onMessageReceived(&midiMessage);
}
lastVirtualKeyboardNoteNumber = virtualKeyboardNoteNumber;
}
void Vega::processVirtualKeyboard() {
IKeyboardControl* virtualKeyboard = (IKeyboardControl*) mVirtualKeyboard;
int virtualKeyboardNoteNumber = virtualKeyboard->GetKey() + virtualKeyboardMinimumNoteNumber;
if (lastVirtualKeyboardNoteNumber >= virtualKeyboardMinimumNoteNumber
&& virtualKeyboardNoteNumber != lastVirtualKeyboardNoteNumber) {
IMidiMsg midiMessage;
midiMessage.MakeNoteOffMsg(lastVirtualKeyboardNoteNumber, 0);
mMIDIReceiver.onMessageReceived(&midiMessage);
}
if (virtualKeyboardNoteNumber >= virtualKeyboardMinimumNoteNumber
&& virtualKeyboardNoteNumber != lastVirtualKeyboardNoteNumber) {
IMidiMsg midiMessage;
midiMessage.MakeNoteOnMsg(virtualKeyboardNoteNumber, virtualKeyboard->GetVelocity(), 0);
mMIDIReceiver.onMessageReceived(&midiMessage);
}
lastVirtualKeyboardNoteNumber = virtualKeyboardNoteNumber;
}
tresult PLUGIN_API IPlugVST3Plugin::process(ProcessData& data)
{
TRACE_PROCESS;
IMutexLock lock(this);
if(data.processContext)
memcpy(&mProcessContext, data.processContext, sizeof(ProcessContext));
//process parameters
IParameterChanges* paramChanges = data.inputParameterChanges;
if (paramChanges)
{
int32 numParamsChanged = paramChanges->getParameterCount();
//it is possible to get a finer resolution of control here by retrieving more values (points) from the queue
//for now we just grab the last one
for (int32 i = 0; i < numParamsChanged; i++)
{
IParamValueQueue* paramQueue = paramChanges->getParameterData(i);
if (paramQueue)
{
int32 numPoints = paramQueue->getPointCount();
int32 offsetSamples;
double value;
if (paramQueue->getPoint(numPoints - 1, offsetSamples, value) == kResultTrue)
{
int idx = paramQueue->getParameterId();
switch (idx)
{
case kBypassParam:
{
bool bypassed = (value > 0.5);
if (bypassed != mIsBypassed)
{
mIsBypassed = bypassed;
}
break;
}
case kPresetParam:
RestorePreset(FromNormalizedParam(value, 0, NPresets(), 1.));
break;
//TODO pitch bend, modwheel etc
default:
if (idx >= 0 && idx < NParams())
{
GetParam(idx)->SetNormalized((double)value);
if (GetGUI()) GetGUI()->SetParameterFromPlug(idx, (double)value, true);
OnParamChange(idx);
}
break;
}
}
}
}
}
if(DoesMIDI())
{
//process events.. only midi note on and note off?
IEventList* eventList = data.inputEvents;
if (eventList)
{
int32 numEvent = eventList->getEventCount();
for (int32 i=0; i<numEvent; i++)
{
Event event;
if (eventList->getEvent(i, event) == kResultOk)
{
IMidiMsg msg;
switch (event.type)
{
case Event::kNoteOnEvent:
{
msg.MakeNoteOnMsg(event.noteOn.pitch, event.noteOn.velocity * 127, event.sampleOffset, event.noteOn.channel);
ProcessMidiMsg(&msg);
break;
}
case Event::kNoteOffEvent:
{
msg.MakeNoteOffMsg(event.noteOff.pitch, event.sampleOffset, event.noteOff.channel);
ProcessMidiMsg(&msg);
break;
}
}
}
}
}
}
#pragma mark process single precision
if (processSetup.symbolicSampleSize == kSample32)
{
if (data.numInputs)
{
if (mScChans)
{
if (getAudioInput(1)->isActive()) // Sidechain is active
{
mSidechainActive = true;
SetInputChannelConnections(0, NInChannels(), true);
}
else
{
if (mSidechainActive)
{
ZeroScratchBuffers();
mSidechainActive = false;
}
SetInputChannelConnections(0, NInChannels(), true);
SetInputChannelConnections(data.inputs[0].numChannels, NInChannels() - mScChans, false);
}
AttachInputBuffers(0, NInChannels() - mScChans, data.inputs[0].channelBuffers32, data.numSamples);
AttachInputBuffers(mScChans, NInChannels() - mScChans, data.inputs[1].channelBuffers32, data.numSamples);
}
else
{
SetInputChannelConnections(0, data.inputs[0].numChannels, true);
SetInputChannelConnections(data.inputs[0].numChannels, NInChannels() - data.inputs[0].numChannels, false);
AttachInputBuffers(0, NInChannels(), data.inputs[0].channelBuffers32, data.numSamples);
}
}
for (int outBus = 0, chanOffset = 0; outBus < data.numOutputs; outBus++)
{
int busChannels = data.outputs[outBus].numChannels;
SetOutputChannelConnections(chanOffset, busChannels, (bool) getAudioOutput(outBus)->isActive());
SetOutputChannelConnections(chanOffset + busChannels, NOutChannels() - (chanOffset + busChannels), false);
AttachOutputBuffers(chanOffset, busChannels, data.outputs[outBus].channelBuffers32);
chanOffset += busChannels;
}
if (mIsBypassed)
PassThroughBuffers(0.0f, data.numSamples);
else
ProcessBuffers(0.0f, data.numSamples); // process buffers single precision
}
#pragma mark process double precision
else if (processSetup.symbolicSampleSize == kSample64)
{
if (data.numInputs)
{
if (mScChans)
{
if (getAudioInput(1)->isActive()) // Sidechain is active
{
mSidechainActive = true;
SetInputChannelConnections(0, NInChannels(), true);
}
else
{
if (mSidechainActive)
{
ZeroScratchBuffers();
mSidechainActive = false;
}
SetInputChannelConnections(0, NInChannels(), true);
SetInputChannelConnections(data.inputs[0].numChannels, NInChannels() - mScChans, false);
}
AttachInputBuffers(0, NInChannels() - mScChans, data.inputs[0].channelBuffers64, data.numSamples);
AttachInputBuffers(mScChans, NInChannels() - mScChans, data.inputs[1].channelBuffers64, data.numSamples);
}
else
{
SetInputChannelConnections(0, data.inputs[0].numChannels, true);
SetInputChannelConnections(data.inputs[0].numChannels, NInChannels() - data.inputs[0].numChannels, false);
AttachInputBuffers(0, NInChannels(), data.inputs[0].channelBuffers64, data.numSamples);
}
}
for (int outBus = 0, chanOffset = 0; outBus < data.numOutputs; outBus++)
{
int busChannels = data.outputs[outBus].numChannels;
SetOutputChannelConnections(chanOffset, busChannels, (bool) getAudioOutput(outBus)->isActive());
SetOutputChannelConnections(chanOffset + busChannels, NOutChannels() - (chanOffset + busChannels), false);
AttachOutputBuffers(chanOffset, busChannels, data.outputs[outBus].channelBuffers64);
chanOffset += busChannels;
}
if (mIsBypassed)
PassThroughBuffers(0.0, data.numSamples);
else
ProcessBuffers(0.0, data.numSamples); // process buffers double precision
}
// Midi Out
// if (mDoesMidi) {
// IEventList eventList = data.outputEvents;
//
// if (eventList)
// {
// Event event;
//
// while (!mMidiOutputQueue.Empty()) {
// //TODO: parse events and add
// eventList.addEvent(event);
// }
// }
// }
return kResultOk;
}
Sequence::Sequence(KeyMap& keymap, int length) : keymap_(keymap), pos(0), playLength_(0), octaves_(1), arpMode_(kUp), insertMode_(kInsertOff)
{
IMidiMsg off;
off.MakeNoteOffMsg(0, 0);
sequence.insert(sequence.begin(), length, off);
}
tresult PLUGIN_API IPlugVST3::process(ProcessData& data)
{
TRACE_PROCESS;
IMutexLock lock(this); // TODO: is this the best place to lock the mutex?
memcpy(&mProcessContext, data.processContext, sizeof(ProcessContext));
//process parameters
IParameterChanges* paramChanges = data.inputParameterChanges;
if (paramChanges)
{
int32 numParamsChanged = paramChanges->getParameterCount();
//it is possible to get a finer resolution of control here by retrieving more values (points) from the queue
//for now we just grab the last one
for (int32 i = 0; i < numParamsChanged; i++)
{
IParamValueQueue* paramQueue = paramChanges->getParameterData(i);
if (paramQueue)
{
int32 numPoints = paramQueue->getPointCount();
int32 offsetSamples;
double value;
if (paramQueue->getPoint(numPoints - 1, offsetSamples, value) == kResultTrue)
{
int idx = paramQueue->getParameterId();
if (idx >= 0 && idx < NParams())
{
GetParam(idx)->SetNormalized((double)value);
if (GetGUI()) GetGUI()->SetParameterFromPlug(idx, (double)value, true);
OnParamChange(idx);
}
}
}
}
}
if(mDoesMidi) {
//process events.. only midi note on and note off?
IEventList* eventList = data.inputEvents;
if (eventList)
{
int32 numEvent = eventList->getEventCount();
for (int32 i=0; i<numEvent; i++)
{
Event event;
if (eventList->getEvent(i, event) == kResultOk)
{
IMidiMsg msg;
switch (event.type)
{
case Event::kNoteOnEvent:
{
msg.MakeNoteOnMsg(event.noteOn.pitch, event.noteOn.velocity * 127, event.sampleOffset, event.noteOn.channel);
ProcessMidiMsg(&msg);
break;
}
case Event::kNoteOffEvent:
{
msg.MakeNoteOffMsg(event.noteOff.pitch, event.sampleOffset, event.noteOff.channel);
ProcessMidiMsg(&msg);
break;
}
}
}
}
}
}
//process audio
if (data.numInputs == 0 || data.numOutputs == 0)
{
// nothing to do
return kResultOk;
}
if (processSetup.symbolicSampleSize == kSample32)
{
float** in = data.inputs[0].channelBuffers32;
float** out = data.outputs[0].channelBuffers32;
if (mScChans)
{
float** side = data.inputs[1].channelBuffers32;
if (getAudioInput(1)->isActive())
{
int totalNInputs = data.inputs[0].numChannels + data.inputs[1].numChannels;
float** allInputs = new float*[totalNInputs];
for (int i = 0; i < data.inputs[0].numChannels; i ++) {
allInputs[i] = in[i];
}
for (int i = 0; i < data.inputs[1].numChannels; i ++) {
allInputs[i + data.inputs[0].numChannels] = side[i];
}
AttachInputBuffers(0, totalNInputs, allInputs, data.numSamples);
mSideChainIsConnected = true;
delete [] allInputs;
}
else
{
AttachInputBuffers(0, data.inputs[0].numChannels, in, data.numSamples);
mSideChainIsConnected = false;
}
}
else
{
AttachInputBuffers(0, data.inputs[0].numChannels, in, data.numSamples);
}
AttachOutputBuffers(0, data.outputs[0].numChannels, out);
ProcessBuffers(0.0f, data.numSamples);
}
else if (processSetup.symbolicSampleSize == kSample64) // TODO: parity for double precision
{
double** in = data.inputs[0].channelBuffers64;
double** out = data.outputs[0].channelBuffers64;
AttachInputBuffers(0, data.inputs[0].numChannels, in, data.numSamples);
AttachOutputBuffers(0, data.outputs[0].numChannels, out);
ProcessBuffers(0.0, data.numSamples);
}
// Midi Out
// if (mDoesMidi) {
// IEventList eventList = data.outputEvents;
//
// if (eventList)
// {
// Event event;
//
// while (!mMidiOutputQueue.Empty()) {
// //TODO: parse events and add
// eventList.addEvent(event);
// }
// }
// }
return kResultOk;
}
void IPlugMultiTargets::ProcessDoubleReplacing(double** inputs, double** outputs, int nFrames)
{
// Mutex is already locked for us.
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double peakL = 0.0, peakR = 0.0;
GetTime(&mTimeInfo);
IKeyboardControl* pKeyboard = (IKeyboardControl*) mKeyboard;
if (pKeyboard->GetKey() != mKey)
{
IMidiMsg msg;
if (mKey >= 0) {
msg.MakeNoteOffMsg(mKey + 48, 0, 0);
mMidiQueue.Add(&msg);
}
mKey = pKeyboard->GetKey();
if (mKey >= 0) {
msg.MakeNoteOnMsg(mKey + 48, pKeyboard->GetVelocity(), 0, 0);
mMidiQueue.Add(&msg);
}
}
for (int offset = 0; offset < nFrames; ++offset, ++in1, ++in2, ++out1, ++out2)
{
while (!mMidiQueue.Empty())
{
IMidiMsg* pMsg = mMidiQueue.Peek();
if (pMsg->mOffset > offset) break;
// TODO: make this work on win sa
#if !defined(OS_WIN) && !defined(SA_API)
SendMidiMsg(pMsg);
#endif
int status = pMsg->StatusMsg();
switch (status)
{
case IMidiMsg::kNoteOn:
case IMidiMsg::kNoteOff:
{
int velocity = pMsg->Velocity();
// Note On
if (status == IMidiMsg::kNoteOn && velocity)
{
mNote = pMsg->NoteNumber();
mFreq = 440. * pow(2., (mNote - 69.) / 12.);
mNoteGain = velocity / 127.;
}
// Note Off
else // if (status == IMidiMsg::kNoteOff || !velocity)
{
if (pMsg->NoteNumber() == mNote)
mNote = -1;
mNoteGain = 0.;
}
break;
}
}
mMidiQueue.Remove();
}
*out1 = sin( 2. * M_PI * mFreq * mPhase / mSampleRate ) * mGainLSmoother.Process(mGainL * mNoteGain);
*out2 = sin( 2. * M_PI * mFreq * 1.01 * (mPhase++) / mSampleRate ) * mGainRSmoother.Process(mGainR * mNoteGain);
peakL = IPMAX(peakL, fabs(*out1));
peakR = IPMAX(peakR, fabs(*out2));
}
const double METER_ATTACK = 0.6, METER_DECAY = 0.05;
double xL = (peakL < mPrevL ? METER_DECAY : METER_ATTACK);
double xR = (peakR < mPrevR ? METER_DECAY : METER_ATTACK);
peakL = peakL * xL + mPrevL * (1.0 - xL);
peakR = peakR * xR + mPrevR * (1.0 - xR);
mPrevL = peakL;
mPrevR = peakR;
if (GetGUI())
{
GetGUI()->SetControlFromPlug(mMeterIdx_L, peakL);
GetGUI()->SetControlFromPlug(mMeterIdx_R, peakR);
}
mMidiQueue.Flush(nFrames);
}