//==============================================================================
bool MidiSequencePlugin::eventRemoved (const int controller, const double automationValue, const float beatNumber)
{
DBG ("Removing:" + String (automationValue) + " " + String (beatNumber));
double noteOnBeats = beatNumber - NOTE_PREFRAMES;
int eventIndex = midiSequence->getNextIndexAtTime (noteOnBeats);
while (eventIndex < midiSequence->getNumEvents ())
{
MidiMessage* eventOn = &midiSequence->getEventPointer (eventIndex)->message;
if (eventOn->isController() && eventOn->getControllerNumber() == controller && eventOn->getControllerValue() == floor(automationValue * 127))
{
{
const ScopedLock sl (parentHost->getCallbackLock());
midiSequence->deleteEvent (eventIndex, true);
}
DBG ("Removed:" + String (eventIndex) + " > " + String (automationValue) + " @ " + String (beatNumber));
if (transport->isPlaying ())
doAllNotesOff = true;
return true;
}
eventIndex++;
}
DBG (">>> Remove failed:" + String (automationValue) + " @ " + String (beatNumber));
return false;
}
void Synthesiser::handleMidiEvent (const MidiMessage& m)
{
if (m.isNoteOn())
{
noteOn (m.getChannel(),
m.getNoteNumber(),
m.getFloatVelocity());
}
else if (m.isNoteOff())
{
noteOff (m.getChannel(),
m.getNoteNumber(),
true);
}
else if (m.isAllNotesOff() || m.isAllSoundOff())
{
allNotesOff (m.getChannel(), true);
}
else if (m.isPitchWheel())
{
const int channel = m.getChannel();
const int wheelPos = m.getPitchWheelValue();
lastPitchWheelValues [channel - 1] = wheelPos;
handlePitchWheel (channel, wheelPos);
}
else if (m.isController())
{
handleController (m.getChannel(),
m.getControllerNumber(),
m.getControllerValue());
}
}
bool MidiControlAction::processIncomingMessage(const MidiMessage& message)
{
if (isLearning)
{
isLearning = false;
messageTemplate = message;
return true;
}
else if (message.isForChannel(messageTemplate.getChannel()))
{
if (messageTemplate.isNoteOnOrOff() && message.isNoteOnOrOff() && message.getNoteNumber() == messageTemplate.getNoteNumber())
{
// toggle!
if (message.isNoteOn() && message.getNoteNumber() == messageTemplate.getNoteNumber())
{
getMappedComponent()->setValue(getMappedComponent()->getValue() >= 0.5f?0.f:1.f);
getMappedComponent()->triggerAsyncUpdate();
}
return true;
}
else if (messageTemplate.isController() && message.isController() && messageTemplate.getControllerNumber() == message.getControllerNumber())
{
//setValue(message.getControllerValue() / 127.0f);
getMappedComponent()->setValue(message.getControllerValue() / 127.0f);
getMappedComponent()->triggerAsyncUpdate();
return true;
}
}
return false;
}
const String getMidiValue(const MidiMessage &m)
{
if (m.isAftertouch())
{
return (String::formatted (" Val:[%4d]", m.getAfterTouchValue()));
}
if (m.isController())
{
return (String::formatted (" Val:[%4d]", m.getControllerValue()));
}
if (m.isNoteOnOrOff())
{
return (String::formatted (" Val:[%4d]", m.getVelocity()));
}
if (m.isPitchWheel())
{
return (String::formatted (" Val:[%4d]", m.getPitchWheelValue()));
}
if (m.isChannelPressure())
{
return (String::formatted (" Val:[%4d]", m.getChannelPressureValue()));
}
return (" Val:[----]");
}
void MPESynthesiser::handleMidiEvent (const MidiMessage& m)
{
if (m.isController())
handleController (m.getChannel(), m.getControllerNumber(), m.getControllerValue());
else if (m.isProgramChange())
handleProgramChange (m.getChannel(), m.getProgramChangeNumber());
MPESynthesiserBase::handleMidiEvent (m);
}
const CtrlrMidiMessageType midiMessageToType (const MidiMessage &midiMessage)
{
if (midiMessage.isController())
{
return (CC);
}
else if (midiMessage.isSysEx())
{
return (SysEx);
}
else if (midiMessage.isNoteOn())
{
return (NoteOn);
}
else if (midiMessage.isNoteOff())
{
return (NoteOff);
}
else if (midiMessage.isAftertouch())
{
return (Aftertouch);
}
else if (midiMessage.isChannelPressure())
{
return (ChannelPressure);
}
else if (midiMessage.isProgramChange())
{
return (ProgramChange);
}
else if (midiMessage.isPitchWheel())
{
return (PitchWheel);
}
else if (midiMessage.isMidiClock())
{
return (MidiClock);
}
else if (midiMessage.isMidiContinue())
{
return (MidiClockContinue);
}
else if (midiMessage.isMidiStart())
{
return (MidiClockStart);
}
else if (midiMessage.isMidiStop())
{
return (MidiClockStop);
}
else if (midiMessage.isActiveSense())
{
return (ActiveSense);
}
return (SysEx);
}
void MidiPedalCallback::handleIncomingMidiMessage (MidiInput *source, const MidiMessage &message)
{
if (message.isController()) {
int x = message.getControllerNumber();
bool button_check = is_item_in_list(x, button_check_list);
if (button_check == true) {
buttonPressed = x;
sendActionMessage("To audio_midi from midiPedalCallback: grab buttonPressed");
}
}
}
void MIDIInputDevice::handleIncomingMidiMessage(MidiInput * source, const MidiMessage & message)
{
if (source != device)
{
DBG("different device");
return;
}
if (message.isNoteOn()) inputListeners.call(&MIDIInputListener::noteOnReceived, message.getChannel(), message.getNoteNumber(), message.getVelocity());
else if(message.isNoteOff()) inputListeners.call(&MIDIInputListener::noteOffReceived, message.getChannel(), message.getNoteNumber(), 0); //force note off to velocity 0
else if(message.isController()) inputListeners.call(&MIDIInputListener::controlChangeReceived, message.getChannel(), message.getControllerNumber(), message.getControllerValue());
else if(message.isSysEx()) inputListeners.call(&MIDIInputListener::sysExReceived, message);
}
//==============================================================================
void MPEZoneLayout::processNextMidiEvent (const MidiMessage& message)
{
if (! message.isController())
return;
MidiRPNMessage rpn;
if (rpnDetector.parseControllerMessage (message.getChannel(),
message.getControllerNumber(),
message.getControllerValue(),
rpn))
{
processRpnMessage (rpn);
}
}
static PyObject *
PyMidiMessage_str(PyObject *self) {
MidiMessage *m = ((PyMidiMessage*)self)->m;
static char s[256];
if(m->isNoteOn()) {
sprintf(s, "<NOTE ON, note: %d (%s), velocity: %d, channel: %d>",
m->getNoteNumber(),
m->getMidiNoteName(m->getNoteNumber(), true, true, 3),
m->getVelocity(),
m->getChannel());
} else if(m->isNoteOff()) {
sprintf(s, "<NOTE OFF, note: %d (%s), channel: %d>",
m->getNoteNumber(),
m->getMidiNoteName(m->getNoteNumber(), true, true, 3),
m->getChannel());
} else if(m->isProgramChange()) {
sprintf(s, "<PROGRAM CHANGE: program: %d, channel: %d>", m->getProgramChangeNumber(), m->getChannel());
} else if(m->isPitchWheel()) {
sprintf(s, "<PITCH WHEEL: value: %d, channel: %d>", m->getPitchWheelValue(), m->getChannel());
} else if(m->isAftertouch()) {
sprintf(s, "<AFTERTOUCH: note: %d (%s) value: %d, channel: %d>",
m->getNoteNumber(),
m->getMidiNoteName(m->getNoteNumber(), true, true, 3),
m->getAfterTouchValue(),
m->getChannel());
} else if(m->isChannelPressure()) {
sprintf(s, "<CHANNEL PRESSURE: pressure: %d, channel: %d>", m->getChannelPressureValue(), m->getChannel());
} else if(m->isController()) {
const char *name = m->getControllerName(m->getControllerNumber());
if(strlen(name) > 0) {
sprintf(s, "<CONTROLLER: %d (\"%s\"), value: %d, channel: %d>",
m->getControllerNumber(),
m->getControllerName(m->getControllerNumber()),
m->getControllerValue(),
m->getChannel());
} else {
sprintf(s, "<CONTROLLER: %d, value: %d, channel: %d>",
m->getControllerNumber(),
m->getControllerValue(),
m->getChannel());
}
} else {
sprintf(s, "<MidiMessage (misc type)>");
}
return PK_STRING(s);
}
void MidiManager::processMidiMessage(const MidiMessage& midi_message, int sample_position) {
if (midi_message.isProgramChange()) {
current_patch_ = midi_message.getProgramChangeNumber();
File patch = LoadSave::loadPatch(current_bank_, current_folder_, current_patch_,
synth_, *gui_state_);
PatchLoadedCallback* callback = new PatchLoadedCallback(listener_, patch);
callback->post();
return;
}
if (midi_message.isNoteOn()) {
engine_->noteOn(midi_message.getNoteNumber(),
midi_message.getVelocity() / (mopo::MIDI_SIZE - 1.0),
0, midi_message.getChannel() - 1);
}
else if (midi_message.isNoteOff())
engine_->noteOff(midi_message.getNoteNumber());
else if (midi_message.isAllNotesOff())
engine_->allNotesOff();
else if (midi_message.isSustainPedalOn())
engine_->sustainOn();
else if (midi_message.isSustainPedalOff())
engine_->sustainOff();
else if (midi_message.isAftertouch()) {
mopo::mopo_float note = midi_message.getNoteNumber();
mopo::mopo_float value = (1.0 * midi_message.getAfterTouchValue()) / mopo::MIDI_SIZE;
engine_->setAftertouch(note, value);
}
else if (midi_message.isPitchWheel()) {
double percent = (1.0 * midi_message.getPitchWheelValue()) / PITCH_WHEEL_RESOLUTION;
double value = 2 * percent - 1.0;
engine_->setPitchWheel(value, midi_message.getChannel());
}
else if (midi_message.isController()) {
int controller_number = midi_message.getControllerNumber();
if (controller_number == MOD_WHEEL_CONTROL_NUMBER) {
double percent = (1.0 * midi_message.getControllerValue()) / MOD_WHEEL_RESOLUTION;
engine_->setModWheel(percent, midi_message.getChannel());
}
else if (controller_number == BANK_SELECT_NUMBER)
current_bank_ = midi_message.getControllerValue();
else if (controller_number == FOLDER_SELECT_NUMBER)
current_folder_ = midi_message.getControllerValue();
midiInput(midi_message.getControllerNumber(), midi_message.getControllerValue());
}
}
void VoicerUGenInternal::handleIncomingMidiMessage (MidiInput* /*source*/, const MidiMessage& message) throw()
{
if(message.isForChannel(midiChannel_) == false) return;
if(message.isNoteOnOrOff())
{
const ScopedLock sl(lock);
sendMidiNote(message.getChannel(), message.getNoteNumber(), message.getVelocity());
}
else if(message.isController())
{
if((message.getControllerNumber() == 123) && (message.getControllerValue() == 0))
{
const ScopedLock sl(lock);
initEvents();
}
getController(message.getControllerNumber()) =
(message.getControllerValue() * (1.f / 127.f));
}
else if(message.isPitchWheel())
{
getPitchWheel() = (jlimit(-8191, 8191, message.getPitchWheelValue() - 8192) * (1.f / 8191.f));
}
else if(message.isChannelPressure())
{
getChannelPressure() = (message.getChannelPressureValue() * (1.f / 127.f));
}
else if(message.isAftertouch())
{
getKeyPressure(message.getNoteNumber()) =
(message.getAfterTouchValue() * (1.f / 127.f));
}
else if(message.isProgramChange())
{
getProgram() = (message.getProgramChangeNumber());
}
else if(message.isAllNotesOff())
{
const ScopedLock sl(lock);
initEvents();
}
}
void Pfm2AudioProcessor::handleIncomingMidiBuffer(MidiBuffer &buffer, int numberOfSamples) {
if (!buffer.isEmpty()) {
MidiBuffer newBuffer;
MidiMessage midiMessage;
int samplePosition;
MidiBuffer::Iterator midiIterator(buffer);
while (midiIterator.getNextEvent(midiMessage, samplePosition)) {
bool copyMessageInNewBuffer = true;
if (midiMessage.isController() && midiMessage.getChannel() == currentMidiChannel) {
switch (midiMessage.getControllerNumber()) {
case 99:
currentNrpn.paramMSB = midiMessage.getControllerValue();
copyMessageInNewBuffer = false;
break;
case 98:
currentNrpn.paramLSB = midiMessage.getControllerValue();
copyMessageInNewBuffer = false;
break;
case 6:
currentNrpn.valueMSB = midiMessage.getControllerValue();
copyMessageInNewBuffer = false;
break;
case 38:
{
currentNrpn.valueLSB = midiMessage.getControllerValue();
copyMessageInNewBuffer = false;
int param = (int)(currentNrpn.paramMSB << 7) + currentNrpn.paramLSB;
int value = (int)(currentNrpn.valueMSB << 7) + currentNrpn.valueLSB;
const MessageManagerLock mmLock;
handleIncomingNrpn(param, value);
break;
}
}
}
if (copyMessageInNewBuffer) {
newBuffer.addEvent(midiMessage, samplePosition);
}
}
buffer.swapWith(newBuffer);
}
}
//==============================================================================
bool MidiSequencePlugin::eventMoved (
const int controllerNum,
const double oldValue,
const float oldBeat,
const double automationValue,
const float beatNumber)
{
DBG ("Moving:" + String (oldValue) + " " + String (oldBeat));
double noteOnBeats = oldBeat - NOTE_PREFRAMES;
int eventIndex = midiSequence->getNextIndexAtTime (noteOnBeats);
while (eventIndex < midiSequence->getNumEvents ())
{
MidiMessage* eventOn = &midiSequence->getEventPointer (eventIndex)->message;
if (eventOn->isController() && eventOn->getControllerNumber() == controllerNum && eventOn->getControllerValue() == floor(oldValue * 127)) // should make this a "matches controller" method
{
MidiMessage msgOn = MidiMessage::controllerEvent (NOTE_CHANNEL, controllerNum, automationValue * 127);
msgOn.setTimeStamp (beatNumber);
{
const ScopedLock sl (parentHost->getCallbackLock());
// remove old events
midiSequence->deleteEvent (eventIndex, true);
midiSequence->addEvent (msgOn);
}
return true;
}
eventIndex++;
}
DBG (">>> Move failed:" + String (oldValue) + " @ " + String (oldBeat));
return false;
}
void Synthesiser::handleMidiEvent (const MidiMessage& m)
{
const int channel = m.getChannel();
if (m.isNoteOn())
{
noteOn (channel, m.getNoteNumber(), m.getFloatVelocity());
}
else if (m.isNoteOff())
{
noteOff (channel, m.getNoteNumber(), m.getFloatVelocity(), true);
}
else if (m.isAllNotesOff() || m.isAllSoundOff())
{
allNotesOff (channel, true);
}
else if (m.isPitchWheel())
{
const int wheelPos = m.getPitchWheelValue();
lastPitchWheelValues [channel - 1] = wheelPos;
handlePitchWheel (channel, wheelPos);
}
else if (m.isAftertouch())
{
handleAftertouch (channel, m.getNoteNumber(), m.getAfterTouchValue());
}
else if (m.isChannelPressure())
{
handleChannelPressure (channel, m.getChannelPressureValue());
}
else if (m.isController())
{
handleController (channel, m.getControllerNumber(), m.getControllerValue());
}
else if (m.isProgramChange())
{
handleProgramChange (channel, m.getProgramChangeNumber());
}
}
const String getMidiNumber(const MidiMessage &m)
{
if (m.isAftertouch())
{
return (String::formatted (" No:[%4d]", m.getNoteNumber()));
}
if (m.isController())
{
return (String::formatted (" No:[%4d]", m.getControllerNumber()));
}
if (m.isNoteOnOrOff())
{
return (String::formatted (" No:[%4d]", m.getNoteNumber()));
}
if (m.isProgramChange())
{
return (String::formatted (" No:[%4d]", m.getProgramChangeNumber()));
}
return (" No:[----]");
}
static String getMidiMessageDescription (const MidiMessage& m)
{
if (m.isNoteOn()) return "Note on " + MidiMessage::getMidiNoteName (m.getNoteNumber(), true, true, 3);
if (m.isNoteOff()) return "Note off " + MidiMessage::getMidiNoteName (m.getNoteNumber(), true, true, 3);
if (m.isProgramChange()) return "Program change " + String (m.getProgramChangeNumber());
if (m.isPitchWheel()) return "Pitch wheel " + String (m.getPitchWheelValue());
if (m.isAftertouch()) return "After touch " + MidiMessage::getMidiNoteName (m.getNoteNumber(), true, true, 3) + ": " + String (m.getAfterTouchValue());
if (m.isChannelPressure()) return "Channel pressure " + String (m.getChannelPressureValue());
if (m.isAllNotesOff()) return "All notes off";
if (m.isAllSoundOff()) return "All sound off";
if (m.isMetaEvent()) return "Meta event";
if (m.isController())
{
String name (MidiMessage::getControllerName (m.getControllerNumber()));
if (name.isEmpty())
name = "[" + String (m.getControllerNumber()) + "]";
return "Controler " + name + ": " + String (m.getControllerValue());
}
return String::toHexString (m.getRawData(), m.getRawDataSize());
}
String ZenMidiVisualiserComponent::getMidiMessageDescription(const MidiMessage& m)
{
if (m.isNoteOn()) return "Note on: " + S(m.getNoteNumber()) + " (" + MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + ") Vel: " + S(m.getVelocity());
if (m.isNoteOff()) return "Note off: " + S(m.getNoteNumber()) + " (" + MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + ")";
if (m.isProgramChange()) return "Program change (Number): " + String(m.getProgramChangeNumber());
if (m.isPitchWheel()) return "Pitch wheel: " + String(m.getPitchWheelValue());
if (m.isAftertouch()) return "After touch: " + MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + ": " + String(m.getAfterTouchValue());
if (m.isChannelPressure()) return "Channel pressure: " + String(m.getChannelPressureValue());
if (m.isAllNotesOff()) return "All notes off";
if (m.isAllSoundOff()) return "All sound off";
if (m.isMetaEvent()) return "Meta event";
if (m.isController())
{
String temp = MidiMessage::getControllerName(m.getControllerNumber());
String name = "Controller [" + S(m.getControllerNumber()) + "]";
if (!temp.isEmpty())
name += " " + temp;
return name + ": " + String(m.getControllerValue());
}
return String::toHexString(m.getRawData(), m.getRawDataSize());
}
//==============================================================================
void MidiSequencePlugin::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
MidiSequencePluginBase::processBlock(buffer, midiMessages);
MidiMessageSequence sourceMidi = *midiSequence;
std::vector<int> doneTheseControllers;
if (transport->isPlaying () && getBoolValue(PROP_SEQENABLED, true))
{
const int blockSize = buffer.getNumSamples ();
MidiBuffer* midiBuffer = midiBuffers.getUnchecked (0);
const int frameCounter = transport->getPositionInFrames ();
const int framesPerBeat = transport->getFramesPerBeat ();
const int nextBlockFrameNumber = frameCounter + blockSize;
const int seqIndex = getLoopRepeatIndex();
const double beatCount = getLoopBeatPosition();
const double frameLenBeatCount = (nextBlockFrameNumber - frameCounter) / (double)framesPerBeat;
double frameEndBeatCount = beatCount + frameLenBeatCount;
if (frameEndBeatCount > getLengthInBeats())
frameEndBeatCount -= getLengthInBeats();
// loop for each controller we need to interpolate
MidiMessage* lastCtrlEvent = NULL;
do
{
lastCtrlEvent = NULL;
// hunt for a controller event before now
int i;
for (i = 0; i < sourceMidi.getNumEvents (); i++)
{
int timeStampInSeq = roundFloatToInt (sourceMidi.getEventTime (i) * framesPerBeat);
int timeStamp = timeStampInSeq + (seqIndex * getLengthInBeats() * framesPerBeat);
MidiMessage* midiMessage = &sourceMidi.getEventPointer (i)->message;
if (timeStamp >= nextBlockFrameNumber || !midiMessage)
break; // event is after now, leave
//if (midiMessage->isController() && (std::find(doneTheseControllers.begin(), doneTheseControllers.end(), midiMessage->getControllerNumber()) == doneTheseControllers.end()))
// lastCtrlEvent = midiMessage;
}
// hunt for a matching event after that one
if (lastCtrlEvent)
{
// store the controller number so we know which controllers we've done
doneTheseControllers.push_back(lastCtrlEvent->getControllerNumber());
MidiMessage* nextCtrlEvent = NULL;
for (; i < sourceMidi.getNumEvents (); i++)
{
MidiMessage* midiMessage = &sourceMidi.getEventPointer (i)->message;
if (midiMessage->isController() && midiMessage->getControllerNumber() == lastCtrlEvent->getControllerNumber())
{
nextCtrlEvent = midiMessage;
break;
}
}
// render an interpolated event!...
if (nextCtrlEvent)
{
double bt = nextCtrlEvent->getTimeStamp();
double at = lastCtrlEvent->getTimeStamp();
double deltaBeats = bt - at;
int a = lastCtrlEvent->getControllerValue();
int b = nextCtrlEvent->getControllerValue();
double now = beatCount + (frameEndBeatCount - beatCount) / 2.0;
double interpRemainBeats = deltaBeats - (now - at);
if (deltaBeats > 0)
{
double nextPart = interpRemainBeats / deltaBeats;
nextPart = 1 - nextPart;
double interpdVal = a + nextPart * (b - a);
MidiMessage interpy = MidiMessage::controllerEvent(lastCtrlEvent->getChannel(), lastCtrlEvent->getControllerNumber(), static_cast<int>(interpdVal));
midiBuffer->addEvent (interpy, (nextBlockFrameNumber - frameCounter) / 2);
}
else
{
DBG ("Negative delta beats when rendering automation!!");
}
}
}
// now we also need to do that again if there are multiple events per frame AND we are interpolating multiple times per frame
// (at the moment only interpolating once per audio frame)
} while (lastCtrlEvent != NULL);
}
}
const String getName(const MidiMessage &m)
{
if (m.isActiveSense())
{
return (" [Active Sense]");
}
if (m.isAftertouch())
{
return (" [Aftertouch]");
}
if (m.isAllNotesOff())
{
return (" [All notes off]");
}
if (m.isAllSoundOff())
{
return (" [All sound off]");
}
if (m.isChannelPressure())
{
return (" [Channel pressure]");
}
if (m.isController())
{
return (" [Controller]");
}
if (m.isFullFrame())
{
return (" [Full frame]");
}
if (m.isMetaEvent())
{
return (" [Meta event]");
}
if (m.isMidiClock())
{
return (" [MIDI Clock]");
}
if (m.isMidiContinue())
{
return (" [MIDI Continue]");
}
if (m.isMidiStart())
{
return (" [MIDI Start]");
}
if (m.isMidiStop())
{
return (" [MIDI Stop]");
}
if (m.isNoteOff())
{
return (" [Note off]");
}
if (m.isNoteOn())
{
return (" [Note on]");
}
if (m.isPitchWheel())
{
return (" [Pitch wheel]");
}
if (m.isProgramChange())
{
return (" [Program change]");
}
if (m.isQuarterFrame())
{
return (" Quarter frame]");
}
if (m.isSysEx())
{
return (" [System exclusive]");
}
return (" [Yet unknown]");
}
//------------------------------------------------------------------------------
void MidiMappingManager::midiCcReceived(const MidiMessage& message,
double secondsSinceStart)
{
if(message.isController())
{
multimap<int, MidiMapping *>::iterator it;
multimap<int, MidiAppMapping *>::iterator it2;
int cc = message.getControllerNumber();
int value = message.getControllerValue();
//Check if it matches any MidiMappings.
for(it=mappings.lower_bound(cc);
it!=mappings.upper_bound(cc);
++it)
{
it->second->ccReceived(value);
}
if(value > 64)
{
//Check if it matches any MidiAppMappings.
for(it2=appMappings.lower_bound(cc);
it2!=appMappings.upper_bound(cc);
++it2)
{
CommandID id = it2->second->getId();
MainPanel *panel = dynamic_cast<MainPanel *>(appManager->getFirstCommandTarget(MainPanel::TransportPlay));
if(panel)
{
if(id != MainPanel::TransportTapTempo)
panel->invokeCommandFromOtherThread(id);
else
{
double tempo = tapHelper.updateTempo(secondsSinceStart);
if(tempo > 0.0)
panel->updateTempoFromOtherThread(tempo);
}
}
}
}
}
else if(message.isMidiMachineControlMessage())
{
if(PropertiesSingleton::getInstance().getUserSettings()->getBoolValue(L"mmcTransport", false))
{
CommandID id = -1;
MainPanel *panel = dynamic_cast<MainPanel *>(appManager->getFirstCommandTarget(MainPanel::TransportPlay));
switch(message.getMidiMachineControlCommand())
{
case MidiMessage::mmc_stop:
id = MainPanel::TransportPlay;
break;
case MidiMessage::mmc_play:
id = MainPanel::TransportPlay;
break;
case MidiMessage::mmc_rewind:
id = MainPanel::TransportRtz;
break;
case MidiMessage::mmc_pause:
id = MainPanel::TransportPlay;
break;
default:
break;
}
if((id > -1) && panel)
panel->invokeCommandFromOtherThread(id);
}
}
else if(message.isProgramChange())
{
if(PropertiesSingleton::getInstance().getUserSettings()->getBoolValue(L"midiProgramChange", false))
{
int newPatch;
MainPanel *panel = dynamic_cast<MainPanel *>(appManager->getFirstCommandTarget(MainPanel::TransportPlay));
newPatch = message.getProgramChangeNumber();
if(panel)
panel->switchPatchFromProgramChange(newPatch);
}
}
}
//==============================================================================
void MidiMonitorEditor::timerCallback ()
{
MidiBuffer tmpBuffer;
int hours, minutes, seconds, frames;
MidiMessage::SmpteTimecodeType timeCode;
MidiMessageCollector* collector = owner->getMessageCollector ();
collector->removeNextBlockOfMessages (tmpBuffer, 1024);
if (! tmpBuffer.isEmpty())
{
String midiLine;
int samplePos = 0;
MidiMessage msg (0xf4, 0.0);
MidiBuffer::Iterator eventIterator (tmpBuffer);
while (eventIterator.getNextEvent (msg, samplePos))
{
midiLine.printf (T("[CH: %d] "), msg.getChannel());
if (msg.isNoteOnOrOff ())
{
midiLine += MidiMessage::getMidiNoteName (msg.getNoteNumber(),
true, true, 0);
midiLine += " ";
midiLine += String ((int) msg.getVelocity ());
if (msg.isNoteOn())
{
midiLine += " ON";
}
else
{
midiLine += " OFF";
}
}
else if (msg.isAllNotesOff())
{
midiLine += "ALL NOTES OFF";
}
else if (msg.isAllSoundOff())
{
midiLine += "ALL SOUND OFF";
}
else if (msg.isPitchWheel())
{
midiLine += "PITCHWEEL: ";
midiLine += String (msg.getPitchWheelValue());
}
else if (msg.isAftertouch())
{
midiLine += "AFTERTOUCH: ";
midiLine += String (msg.getAfterTouchValue());
}
else if (msg.isChannelPressure())
{
midiLine += "CHANNELPRESSURE: ";
midiLine += String (msg.getChannelPressureValue());
}
else if (msg.isSysEx())
{
midiLine += "SYSEX: ";
midiLine += String (msg.getSysExDataSize());
midiLine += " bytes";
}
else if (msg.isProgramChange())
{
midiLine += "PROGRAM CHANGE: ";
midiLine += String (msg.getProgramChangeNumber());
midiLine += " (";
midiLine += MidiMessage::getGMInstrumentName (msg.getProgramChangeNumber());
midiLine += ")";
}
else if (msg.isController())
{
midiLine += "CC: #";
midiLine += String (msg.getControllerNumber());
midiLine += " (";
midiLine += MidiMessage::getControllerName (msg.getControllerNumber());
midiLine += ") = ";
midiLine += String (msg.getControllerValue());
}
else if (msg.isTimeSignatureMetaEvent ())
{
int newNumerator, newDenominator;
msg.getTimeSignatureInfo (newNumerator, newDenominator);
midiLine += "TIME SIGNATURE: ";
midiLine += String (newNumerator);
midiLine += " / ";
midiLine += String (newDenominator);
}
else if (msg.isTempoMetaEvent ())
{
midiLine += "TEMPO: ";
midiLine += String (msg.getTempoSecondsPerQuarterNote ());
//midiLine += " ";
//midiLine += String (msg.getTempoMetaEventTickLength (ticksPerQuarterNote));
}
else if (msg.isMidiMachineControlMessage())
{
midiLine += "MIDI CONTROL: ";
switch (msg.getMidiMachineControlCommand())
{
case MidiMessage::mmc_stop: midiLine += "stop"; break;
case MidiMessage::mmc_play: midiLine += "play"; break;
case MidiMessage::mmc_deferredplay: midiLine += "deferredplay"; break;
case MidiMessage::mmc_fastforward: midiLine += "fastforward"; break;
case MidiMessage::mmc_rewind: midiLine += "rewind"; break;
case MidiMessage::mmc_recordStart: midiLine += "recordStart"; break;
case MidiMessage::mmc_recordStop: midiLine += "recordStop"; break;
case MidiMessage::mmc_pause: midiLine += "pause"; break;
}
}
else if (msg.isMidiStart ())
{
midiLine += "MIDI START: ";
}
else if (msg.isMidiContinue ())
{
midiLine += "MIDI CONTINUE: ";
}
else if (msg.isMidiStop ())
{
midiLine += "MIDI STOP: ";
}
else if (msg.isSongPositionPointer ())
{
midiLine += "SONG POSITION: ";
midiLine += String (msg.getSongPositionPointerMidiBeat ());
}
else if (msg.isQuarterFrame ())
{
midiLine += "QUARTER FRAME: ";
midiLine += String (msg.getQuarterFrameSequenceNumber ());
midiLine += " ";
midiLine += String (msg.getQuarterFrameValue ());
}
else if (msg.isFullFrame ())
{
midiLine += "FULL FRAME: ";
msg.getFullFrameParameters (hours, minutes, seconds, frames, timeCode);
midiLine += String (hours);
midiLine += ":";
midiLine += String (minutes);
midiLine += ":";
midiLine += String (seconds);
midiLine += ":";
midiLine += String (frames);
midiLine += " timecode: ";
switch (timeCode) {
case MidiMessage::fps24: midiLine += "fps24"; break;
case MidiMessage::fps25: midiLine += "fps25"; break;
case MidiMessage::fps30drop: midiLine += "fps30drop"; break;
case MidiMessage::fps30: midiLine += "fps30"; break;
}
}
else if (msg.isMidiMachineControlGoto (hours, minutes, seconds, frames))
{
midiLine += "MIDI CONTROL GOTO: ";
midiLine += String (hours);
midiLine += ":";
midiLine += String (minutes);
midiLine += ":";
midiLine += String (seconds);
midiLine += ":";
midiLine += String (frames);
}
midiOutputEditor->insertTextAtCursor (midiLine + T("\n"));
}
}
}
void stepQuickEdit::messageTypeChanged()
{
MidiMessage *m = 0;
MidiBuffer *mB = 0;
if (editorComponent)
{
deleteAndZero (editorComponent);
}
if (midiMessage == 0)
{
return;
}
m = midiMessage->getMidiMessage();
if (m)
{
if (m->isNoteOn())
{
addAndMakeVisible (editorComponent = new stepEditNote(midiMessage));
typeCombo->setSelectedId (noteOn, true);
}
else if (m->isProgramChange())
{
typeCombo->setSelectedId (ProgramChange, true);
}
else if (m->isController())
{
addAndMakeVisible (editorComponent = new stepEditController(midiMessage));
typeCombo->setSelectedId (Controller, true);
}
else if (m->isMidiMachineControlMessage())
{
typeCombo->setSelectedId (MMC, true);
}
else if (m->isSysEx())
{
addAndMakeVisible (editorComponent = new stepEditSysex(midiMessage));
typeCombo->setSelectedId (SysEx, true);
}
resized();
}
mB = midiMessage->getMidiBuffer();
if (mB == 0)
return;
if (!m && mB)
{
MidiBuffer::Iterator i(*mB);
int len;
MidiMessage message (0xf4, 0.0);
if (i.getNextEvent (message, len))
{
uint8 *data = message.getRawData();
if (*data == 0xb0)
{
addAndMakeVisible (editorComponent = new stepEditController(midiMessage));
typeCombo->setSelectedId (Controller, true);
}
if (*data == 0xf0)
{
addAndMakeVisible (editorComponent = new stepEditSysex(midiMessage));
typeCombo->setSelectedId (SysEx, true);
}
resized();
}
}
}
void InstanceProcessor::processBlock(AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
for(int i = getTotalNumInputChannels(); i < getTotalNumOutputChannels(); ++i)
{
buffer.clear(i, 0, buffer.getNumSamples());
}
bool infos = false;
AudioPlayHead* playhead = getPlayHead();
if(playhead && m_patch_tie)
{
infos = playhead->getCurrentPosition(m_playinfos);
}
lock();
{
m_midi.clear();
if(infos)
{
m_playing_list.setFloat(0, m_playinfos.isPlaying);
m_playing_list.setFloat(1, m_playinfos.timeInSeconds);
sendMessageAnything(m_patch_tie, s_playing, m_playing_list);
m_measure_list.setFloat(0, m_playinfos.bpm);
m_measure_list.setFloat(1, m_playinfos.timeSigNumerator);
m_measure_list.setFloat(2, m_playinfos.timeSigDenominator);
m_measure_list.setFloat(3, m_playinfos.ppqPosition);
m_measure_list.setFloat(4, m_playinfos.ppqPositionOfLastBarStart);
sendMessageAnything(m_patch_tie, s_measure, m_measure_list);
}
for(size_t i = 0; i < m_parameters.size() && m_parameters[i].isValid(); ++i)
{
sendMessageFloat(m_parameters[i].getTie(), m_parameters[i].getValueNonNormalized());
}
MidiMessage message;
MidiBuffer::Iterator it(midiMessages);
int position = midiMessages.getFirstEventTime();
while(it.getNextEvent(message, position))
{
if(message.isNoteOnOrOff())
{
sendMidiNote(message.getChannel(), message.getNoteNumber(), message.getVelocity());
}
else if(message.isController())
{
sendMidiControlChange(message.getChannel(), message.getControllerNumber(), message.getControllerValue());
}
else if(message.isPitchWheel())
{
sendMidiPitchBend(message.getChannel(), message.getPitchWheelValue());
}
else if(message.isChannelPressure())
{
sendMidiAfterTouch(message.getChannel(), message.getChannelPressureValue());
}
else if(message.isAftertouch())
{
sendMidiPolyAfterTouch(message.getChannel(), message.getNoteNumber(), message.getAfterTouchValue());
}
else if(message.isProgramChange())
{
sendMidiProgramChange(message.getChannel(), message.getProgramChangeNumber());
}
}
}
midiMessages.clear();
performDsp(buffer.getNumSamples(),
getTotalNumInputChannels(), buffer.getArrayOfReadPointers(),
getTotalNumOutputChannels(), buffer.getArrayOfWritePointers());
midiMessages.swapWith(m_midi);
unlock();
}
void MidiControllerAutomationHandler::handleParameterData(MidiBuffer &b)
{
const bool bufferEmpty = b.isEmpty();
const bool noCCsUsed = !anyUsed && !unlearnedData.used;
if (bufferEmpty || noCCsUsed) return;
tempBuffer.clear();
MidiBuffer::Iterator mb(b);
MidiMessage m;
int samplePos;
while (mb.getNextEvent(m, samplePos))
{
bool consumed = false;
if (m.isController())
{
const int number = m.getControllerNumber();
if (isLearningActive())
{
setUnlearndedMidiControlNumber(number, sendNotification);
}
for (auto& a : automationData[number])
{
if (a.used)
{
jassert(a.processor.get() != nullptr);
auto normalizedValue = (double)m.getControllerValue() / 127.0;
if (a.inverted) normalizedValue = 1.0 - normalizedValue;
const double value = a.parameterRange.convertFrom0to1(normalizedValue);
const float snappedValue = (float)a.parameterRange.snapToLegalValue(value);
if (a.macroIndex != -1)
{
a.processor->getMainController()->getMacroManager().getMacroChain()->setMacroControl(a.macroIndex, (float)m.getControllerValue(), sendNotification);
}
else
{
if (a.lastValue != snappedValue)
{
a.processor->setAttribute(a.attribute, snappedValue, sendNotification);
a.lastValue = snappedValue;
}
}
consumed = true;
}
}
}
if (!consumed) tempBuffer.addEvent(m, samplePos);
}
b.clear();
b.addEvents(tempBuffer, 0, -1, 0);
}
void MIDIReceiver::handleIncomingMidiMessage (MidiInput *source, const MidiMessage &message)
{
DBG("midi in");
// is this midi input source enabled
if(_MidiDeviceManager->isMidiInputEnabled(source->getName()))
{
DBG(source->getName());
if(message.isController() && _MidiDeviceManager->isCcEnabled(source->getName(), true)
&& appProperties->getUserSettings()->getIntValue("midiInputChannel") == message.getChannel())
{
DBG(message.getControllerNumber() );
// reference counted Signal ( string command, string origin )
Signal::SignalP ledStateSignal = new Signal("SEND_OSC", "RCV_MIDI");
ledStateSignal->addStringArg("/nomestate/grid/led/set");
// get the x position: LED bumber % 8
ledStateSignal->addIntArg(message.getControllerNumber() % 8);
// get the y position: LED number / 8
ledStateSignal->addIntArg(message.getControllerNumber() / 8);
// get the LED state: toggleState
int ledState;
if (message.getControllerValue() > 0) {
ledState = 1;
}
ledStateSignal->addIntArg(ledState);
_mCenter->handleSignal(*ledStateSignal);
}
else if (message.isNoteOn() && _MidiDeviceManager->isNoteEnabled(source->getName(), true)
&& appProperties->getUserSettings()->getIntValue("midiInputChannel") == message.getChannel())
{
// lets set the color based off MIDI note Velocity
int MIDIVelocity = message.getVelocity();
int r = 0;
int g = 0;
int b = 0;
if (MIDIVelocity > 0) {
// red
if (MIDIVelocity <= 22)
{
r = 127;
}
// yellow
else if (MIDIVelocity <= 43)
{
r = 127;
g = 127;
}
// green
else if (MIDIVelocity <= 64)
{
g = 127;
}
// teal
else if (MIDIVelocity <= 85)
{
g = 127;
b = 127;
}
// blue
else if (MIDIVelocity <= 106)
{
b = 127;
}
// purple
else
{
b = 127;
r = 127;
}
}
// reference counted Signal ( string command, string origin )
Signal::SignalP ledColourSignal = new Signal("SEND_OSC", "RCV_MIDI");
ledColourSignal->addStringArg("/nomestate/grid/led/color");
// get the x position: LED bumber % 8
ledColourSignal->addIntArg(message.getNoteNumber() % 8);
// get the y position: LED number / 8
ledColourSignal->addIntArg(message.getNoteNumber() / 8);
// get the LED RED:
ledColourSignal->addIntArg(r);
// get the LED GREEN:
ledColourSignal->addIntArg(g);
// get the LED BLUE:
ledColourSignal->addIntArg(b);
_mCenter->handleSignal(*ledColourSignal);
// reference counted Signal ( string command, string origin )
Signal::SignalP ledStateSignal = new Signal("SEND_OSC", "RCV_MIDI");
ledStateSignal->addStringArg("/nomestate/grid/led/set");
// get the x position: LED bumber % 8
ledStateSignal->addIntArg(message.getNoteNumber() % 8);
// get the y position: LED number / 8
ledStateSignal->addIntArg(message.getNoteNumber() / 8);
// get the LED state: toggleState
ledStateSignal->addIntArg(1);
_mCenter->handleSignal(*ledStateSignal);
}
else if (message.isNoteOff() && _MidiDeviceManager->isNoteEnabled(source->getName(), true)
&& appProperties->getUserSettings()->getIntValue("midiInputChannel") == message.getChannel())
{
// reference counted Signal ( string command, string origin )
Signal::SignalP ledStateSignal = new Signal("SEND_OSC", "RCV_MIDI");
ledStateSignal->addStringArg("/nomestate/grid/led/set");
// get the x position: LED bumber % 8
ledStateSignal->addIntArg(message.getNoteNumber() % 8);
// get the y position: LED number / 8
ledStateSignal->addIntArg(message.getNoteNumber() / 8);
// get the LED state: toggleState
ledStateSignal->addIntArg(0);
_mCenter->handleSignal(*ledStateSignal);
}
}
}