void SpikeDisplayNode::handleEvent(int eventType, MidiMessage& event, int samplePosition) { //std::cout << "Received event of type " << eventType << std::endl; if (eventType == SPIKE) { const uint8_t* dataptr = event.getRawData(); int bufferSize = event.getRawDataSize(); if (bufferSize > 0) { SpikeObject newSpike; bool isValid = unpackSpike(&newSpike, dataptr, bufferSize); if (isValid) { int electrodeNum = newSpike.source; Electrode& e = electrodes.getReference(electrodeNum); // std::cout << electrodeNum << std::endl; bool aboveThreshold = false; // update threshold / check threshold for (int i = 0; i < e.numChannels; i++) { e.detectorThresholds.set(i, float(newSpike.threshold[i])); // / float(newSpike.gain[i])); aboveThreshold = aboveThreshold | checkThreshold(i, e.displayThresholds[i], newSpike); } if (aboveThreshold) { // add to buffer if (e.currentSpikeIndex < displayBufferSize) { // std::cout << "Adding spike " << e.currentSpikeIndex + 1 << std::endl; e.mostRecentSpikes.set(e.currentSpikeIndex, newSpike); e.currentSpikeIndex++; } // save spike if (isRecording) { CoreServices::RecordNode::writeSpike(newSpike,e.recordIndex); } } } } } }
void sendMessageNow (const MidiMessage& message) { if (message.getRawDataSize() > maxEventSize) { maxEventSize = message.getRawDataSize(); snd_midi_event_free (midiParser); snd_midi_event_new (maxEventSize, &midiParser); } snd_seq_event_t event; snd_seq_ev_clear (&event); snd_midi_event_encode (midiParser, message.getRawData(), message.getRawDataSize(), &event); snd_midi_event_reset_encode (midiParser); snd_seq_ev_set_source (&event, 0); snd_seq_ev_set_subs (&event); snd_seq_ev_set_direct (&event); snd_seq_event_output (seqHandle, &event); snd_seq_drain_output (seqHandle); }
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:[----]"); }
int main(int argc, char* argv[]) { int incount = MidiInPort::getNumPorts(); int outcount = MidiOutPort::getNumPorts(); Array<ArrayInt> connections; connections.setSize(incount); int i, j; for (i=0; i<incount; i++) { connections[i].setSize(outcount); connections[i].setAll(1); } // temporary connections for now: // connections[0][2] = 0; // connections[1][2] = 0; cout << "There are " << incount << " MIDI inputs" << endl; cout << "and " << outcount << " MIDI outputs" << endl; MidiMessage message; Array<MidiInput> midiins; for (i=0; i<incount; i++) { midiins[i].setPort(i); midiins[i].open(); } Array<MidiOutPort> midiouts; midiouts.setSize(outcount); for (i=0; i<outcount; i++) { midiouts[i].setPort(i); midiouts[i].open(); cout << "opened MIDI output number " << i << endl; } connections[0][3] = 0; displayPatchBay(connections); int done = 0; while (!done) { for (i=0; i<incount; i++) { while (midiins[i].getCount() > 0) { message = midiins[i].extract(); if (message.p1() == A0) { done = 1; } cout << "[" << i << ":"; for (j=0; j<outcount; j++) { if (connections[i][j]) { cout << j << " "; sendData(message, midiouts[j], midiins[i]); } } cout << "]" << flush; } } } return 0; }
void MIDIMostRecentNoteInternal::handleIncomingMidiMessage (MidiInput* source, const MidiMessage& message) throw() { if(port_ != 0 && port_ != source) return; if(message.isForChannel(midiChannel_) == false) return; if(message.isNoteOn() == false) return; setNormalisedValue(message.getNoteNumber() / 127.f); }
const MemoryBlock CtrlrMIDITransaction::getDataFromResponse(const MidiMessage &messageToExtractFrom) { MemoryBlock returnData; MemoryBlock temp(messageToExtractFrom.getRawData(), messageToExtractFrom.getRawDataSize()); returnData.copyFrom (temp.getData(), getResponsePrefixLength(), getResponseDataLength()); return (returnData); }
void MidiOutput::sendMessageNow (const MidiMessage& message) { #if JUCE_IOS const MIDITimeStamp timeStamp = mach_absolute_time(); #else const MIDITimeStamp timeStamp = AudioGetCurrentHostTime(); #endif HeapBlock<MIDIPacketList> allocatedPackets; MIDIPacketList stackPacket; MIDIPacketList* packetToSend = &stackPacket; const size_t dataSize = (size_t) message.getRawDataSize(); if (message.isSysEx()) { const int maxPacketSize = 256; int pos = 0, bytesLeft = (int) dataSize; const int numPackets = (bytesLeft + maxPacketSize - 1) / maxPacketSize; allocatedPackets.malloc ((size_t) (32 * (size_t) numPackets + dataSize), 1); packetToSend = allocatedPackets; packetToSend->numPackets = (UInt32) numPackets; MIDIPacket* p = packetToSend->packet; for (int i = 0; i < numPackets; ++i) { p->timeStamp = timeStamp; p->length = (UInt16) jmin (maxPacketSize, bytesLeft); memcpy (p->data, message.getRawData() + pos, p->length); pos += p->length; bytesLeft -= p->length; p = MIDIPacketNext (p); } } else if (dataSize < 65536) // max packet size { const size_t stackCapacity = sizeof (stackPacket.packet->data); if (dataSize > stackCapacity) { allocatedPackets.malloc ((sizeof (MIDIPacketList) - stackCapacity) + dataSize, 1); packetToSend = allocatedPackets; } packetToSend->numPackets = 1; MIDIPacket& p = *(packetToSend->packet); p.timeStamp = timeStamp; p.length = (UInt16) dataSize; memcpy (p.data, message.getRawData(), dataSize); } else { jassertfalse; // packet too large to send! return; } static_cast<CoreMidiHelpers::MidiPortAndEndpoint*> (internal)->send (packetToSend); }
void sendData(MidiMessage& m, MidiOutPort& output, MidiInput& input) { int count = m.getParameterCount(); if (count >= 0 && count <= 2) { if (count >= 0) output.rawsend(m.p0()); if (count >= 1) output.rawsend(m.p0(), m.p1()); if (count >= 2) output.rawsend(m.p0(), m.p1(), m.p2()); } }
const String getMidiChannel(const MidiMessage &m) { if (m.getChannel() > 0) { return (String::formatted (" Ch:[%2d]", m.getChannel())); } return (" Ch:[--]"); }
void Loop::sendCurrentNoteToBuffer(MidiBuffer& buffer, int sample_number, int velocity) { MidiMessage m = this->getEventPointer(currentIndex)->message; //playingNote[m.getNoteNumber()][m.getChannel()-1][0] = jlimit(0,127,m.getNoteNumber()+getTransposition()); m.setNoteNumber(jlimit(0,127,m.getNoteNumber()+getTransposition())); m.setVelocity((((float)velocity*midiScaler * velocitySensitivity) + (1.f-velocitySensitivity))); if (outChannel>0) m.setChannel(outChannel); buffer.addEvent(m,sample_number); indexOfLastNoteOn=currentIndex; }
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"); } } }
StringTS::StringTS(MidiMessage& event) { const uint8* dataptr = event.getRawData(); int bufferSize = event.getRawDataSize(); len = bufferSize - 20; str = new uint8[len]; memcpy(str, dataptr+6, len); memcpy(×tamp, dataptr +6+ len, 8); }
void processMidiCommand(MidiMessage& message) { if (message.p0() != 0x90 || message.p2() == 0) { return; } switch (message.p1()) { case 60: // Middle C = beat keyboardchar(' '); break; case 61: // C# = amplitude control { double amp = performance.getAmp(); amp = amp * message.p2() / 64; if (amp < 0) { amp = 0; } else if (amp > 127) { amp = 127; } performance.setAmp((int)amp); } break; case 71: // B = 1 beat tempo follow keyboardchar('1'); break; case 72: // C = 2 beat tempo follow keyboardchar('2'); break; case 73: // C# = 3 beat tempo follow keyboardchar('3'); break; case 74: // D = 4 beat tempo follow keyboardchar('4'); break; case 79: // G = constant tempo follow keyboardchar('9'); break; case 80: // G# = automatic keyboardchar('0'); break; case 62: // amplitude decrease keyboardchar('['); break; case 63: // amplitude increase keyboardchar(']'); break; case 64: // tempo decrease keyboardchar('-'); break; case 65: // tempo increase keyboardchar('='); break; } }
void mainloopalgorithms(void) { if (synth.getNoteCount() > 0) { nextActionTime = t_time; message = synth.extractNote(); if (message.p2() == 0) { // note off keyCount--; if (keyCount < 0) { keyCount = 0; } switch (message.p1()) { case C3: lastOffTime[1] = t_time; break; case D3: lastOffTime[2] = t_time; break; case E3: lastOffTime[3] = t_time; break; case F3: lastOffTime[4] = t_time; break; case G3: lastOffTime[5] = t_time; break; case C4: lastOffTime[6] = t_time; break; case D4: lastOffTime[7] = t_time; break; case E4: lastOffTime[8] = t_time; break; case F4: lastOffTime[9] = t_time; break; case G4: lastOffTime[10] = t_time; break; } } else { // note on keyCount++; keysOn.insert(message.p1()); onKey2 = onKey1; switch (message.p1()) { case C3: lastOnTime[1] = t_time; onKey1 = 1; break; case D3: lastOnTime[2] = t_time; onKey1 = 2; break; case E3: lastOnTime[3] = t_time; onKey1 = 3; break; case F3: lastOnTime[4] = t_time; onKey1 = 4; break; case G3: lastOnTime[5] = t_time; onKey1 = 5; break; case C4: lastOnTime[6] = t_time; onKey1 = 6; break; case D4: lastOnTime[7] = t_time; onKey1 = 7; break; case E4: lastOnTime[8] = t_time; onKey1 = 8; break; case F4: lastOnTime[9] = t_time; onKey1 = 9; break; case G4: lastOnTime[10] = t_time; onKey1 = 10; break; } } } if (nextActionTime + repeatRate <= t_time) { nextActionTime = t_time; } event = makeEventDecision(); if (event > 0) { if (shift) { event = toupper(event); } cout << (char)event << flush; } }
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); }
bool MidiMessageBox::SendMessageAndWaitReply(MidiOutput *out, MidiMessage &msg, int msec) { if (!out) return false; Logger::getCurrentLogger()->writeToLog("midiout: send message and wait reply"); string dbg = ToHexString(msg.getRawData(), msg.getRawDataSize()); Logger::getCurrentLogger()->writeToLog(dbg); std::unique_lock<std::mutex> lck(_mutex); out->sendMessageNow(msg); return std::cv_status::no_timeout == _reply_cv.wait_for(lck, std::chrono::milliseconds(msec)); }
void DrumMachine::getNextAudioBlock(const AudioSourceChannelInfo& bufferToFill) { // std::cout << "drum machine!!" << std::endl; auto& transport = audioEngine.getTransport(); if (transport.isPlaying()) { int frameStartSamples = transport.getFrameStartSamples(); float frameStartTicks = transport.getFrameStartTicks(); float frameEndTicks = transport.getFrameEndTicks(); if ((int) frameStartTicks < (int) frameEndTicks) { int tick = (int) frameEndTicks; if (patternLength != 0) { int ntick = tick % patternLength; for (int voice = 0; voice < NUM_DRUM_VOICES; voice++) { if (mute[voice]) continue; if (pattern[voice][ntick] > 0) { // we need to queue the appropriate note in the drum machine's synth. int offset = transport.ticksToSamples(tick) - frameStartSamples; if (offset > 0) { MidiMessage msg = MidiMessage::noteOn(1, voice, (float) 1.0); msg.setTimeStamp(offset); midiCollector.addMessageToQueue(msg); } } } } } } // the synth always adds its output to the audio buffer, so we have to clear it // first.. bufferToFill.clearActiveBufferRegion(); // fill a midi buffer with incoming messages from the midi input. MidiBuffer incomingMidi; midiCollector.removeNextBlockOfMessages(incomingMidi, bufferToFill.numSamples); // pass these messages to the keyboard state so that it can update the component // to show on-screen which keys are being pressed on the physical midi keyboard. // This call will also add midi messages to the buffer which were generated by // the mouse-clicking on the on-screen keyboard. keyboardState.processNextMidiBuffer(incomingMidi, 0, bufferToFill.numSamples, true); // and now get the synth to process the midi events and generate its output. synth.renderNextBlock(*bufferToFill.buffer, incomingMidi, 0, bufferToFill.numSamples); bufferToFill.buffer->applyGain(0, 0, bufferToFill.numSamples, 0.2); bufferToFill.buffer->applyGain(1, 0, bufferToFill.numSamples, 0.2); }
void mainloopalgorithms(void) { while (synth.getNoteCount() > 0) { noteMessage = synth.extractNote(); if (noteMessage.p2() != 0) { // ignore note off commands synth.play(0, shadowNote, 0); // turn off last note shadowNote = noteMessage.p1() + shadowSide * shadowDistance; if (shadowNote > 0 && shadowNote < 128) { synth.play(0, shadowNote, noteMessage.p2()); } else { shadowNote = 0; } } } }
static PyObject * MidiOut_sendMessage(MidiOut *self, PyObject *args) { PyObject *a0 = NULL; if(PyArg_ParseTuple(args, "O", &a0) == 0) return NULL; MidiMessage *created = NULL; // delete if set MidiMessage *midi = NULL; if(PyMidiMessage_Check(a0)) { midi = ((PyMidiMessage *) a0)->m; } else if(PyLong_Check(a0)) { PyErr_SetString(rtmidi_Error, "long ctor args not supported yet."); return NULL; /* int i0 = (int) PyLong_AsUnsignedLong(a0); printf("MidiOut_sendMessage: %i\n", i0); midi = created = new MidiMessage(i0); */ } else { PyErr_SetString(rtmidi_Error, "argument 1 must be of type MidiMessage or a number."); return NULL; } std::vector<unsigned char> outMessage; uint8 *data = midi->getRawData(); for(int i=0; i < midi->getRawDataSize(); ++i) outMessage.push_back((unsigned char) data[i]); try { self->rtmidi->sendMessage(&outMessage); } catch(RtMidiError &error) { PyErr_SetString(rtmidi_Error, error.what()); if(created) delete created; return NULL; } if(created) delete created; Py_RETURN_NONE; }
void mainloopalgorithms(void) { while (synth.getNoteCount() > 0) { message = synth.extractNote(); if (message.is_note_off()) { continue; } returnpitch = message.p1(); returnvelocity = message.p2(); // returntime = message.time; returntime = t_time; dtime = (short)(returntime - outtimes[returnpitch]); if (dtime > 500) { // ignore return times which take more than 0.5 sec continue; } vchange = returnvelocity - outvels[returnpitch]; velchange[returnpitch][outvels[returnpitch]].append(vchange); deltatimes[returnpitch][outvels[returnpitch]].append(dtime); } if (!playstate) { return; } if (nextnotetime <= t_time) { currentnote += 11; if (currentnote > 127) { currentnote -= 127; } if (currentnote < A0 || currentnote > C8) { return; } velocity = rand() % 127 + 1; // random velocity between 1 and 127 voices[currvoice].off(); outvels[currentnote] = velocity; outtimes[currentnote] = mainTimer.getTime(); voices[currvoice++].play(0, currentnote, velocity); if (currvoice >= maxvoices) { currvoice = 0; } notecount++; nextnotetime = t_time + duration; } }
void RecordNode::handleEvent(int eventType, MidiMessage& event, int samplePosition) { if (isRecording) { if (isWritableEvent(eventType)) { if (*(event.getRawData()+4) > 0) // saving flag > 0 (i.e., event has not already been processed) { uint8 sourceNodeId = event.getNoteNumber(); int64 timestamp = timestamps[sourceNodeId] + samplePosition; m_eventQueue->addEvent(event, timestamp, eventType); } } } }
//============================================================================== void MPEZoneLayout::processNextMidiEvent (const MidiMessage& message) { if (! message.isController()) return; MidiRPNMessage rpn; if (rpnDetector.parseControllerMessage (message.getChannel(), message.getControllerNumber(), message.getControllerValue(), rpn)) { processRpnMessage (rpn); } }
void CtrlrSysexProcessor::sysExProcess (const Array<CtrlrSysexToken> &tokens, MidiMessage &m, const int value, const int channel) { if (tokens.size() != m.getRawDataSize()) return; uint8 *dataPtr = (uint8 *)m.getRawData(); for (int i=0; i<m.getRawDataSize(); i++) { sysExProcessToken (tokens.getReference(i), dataPtr+i, value, channel); } sysexProcessPrograms(tokens, m); sysexProcessChecksums(tokens, m); }
//============================================================================== void MainContentComponent::handleIncomingMidiMessage (MidiInput* /*source*/, const MidiMessage &message) { // This is called on the MIDI thread if (message.isNoteOnOrOff()) postMessage (new MidiCallbackMessage (message)); }
void PulsePalOutput::handleEvent(int eventType, MidiMessage& event, int sampleNum) { if (eventType == TTL) { // std::cout << "Received an event!" << std::endl; const uint8* dataptr = event.getRawData(); // int eventNodeId = *(dataptr+1); int eventId = *(dataptr+2); int eventChannel = *(dataptr+3); for (int i = 0; i < channelTtlTrigger.size(); i++) { if (eventId == 1 && eventChannel == channelTtlTrigger[i] && channelState[i]) { pulsePal.triggerChannel(i+1); } if (eventChannel == channelTtlGate[i]) { if (eventId == 1) channelState.set(i, true); else channelState.set(i, false); } } } }
void PhaseDetector::handleEvent(int eventType, MidiMessage& event, int sampleNum) { // MOVED GATING TO PULSE PAL OUTPUT! // now use to randomize phase for next trial //std::cout << "GOT EVENT." << std::endl; if (eventType == TTL) { const uint8* dataptr = event.getRawData(); // int eventNodeId = *(dataptr+1); int eventId = *(dataptr+2); int eventChannel = *(dataptr+3); //int eventTime = event.getTimeStamp(); // // std::cout << "Received event from " << eventNodeId << ", channel " // // << eventChannel << ", with ID " << eventId << std::endl; // if (eventId == 1 && eventChannel == 5) // { // canBeTriggered = true; // } if (eventId == 0 && eventChannel == 5) { triggerOnPeak = randomNumberGenerator.nextBool(); } } }
void MidiKeyboardState::processNextMidiEvent (const MidiMessage& message) { if (message.isNoteOn()) { noteOnInternal (message.getChannel(), message.getNoteNumber(), message.getFloatVelocity()); } else if (message.isNoteOff()) { noteOffInternal (message.getChannel(), message.getNoteNumber(), message.getFloatVelocity()); } else if (message.isAllNotesOff()) { for (int i = 0; i < 128; ++i) noteOffInternal (message.getChannel(), i, 0.0f); } }
void PhaseDetector::handleEvent(int eventType, MidiMessage& event, int sampleNum) { // MOVED GATING TO PULSE PAL OUTPUT! // now use to randomize phase for next trial //std::cout << "GOT EVENT." << std::endl; if (eventType == TTL) { const uint8* dataptr = event.getRawData(); // int eventNodeId = *(dataptr+1); int eventId = *(dataptr+2); int eventChannel = *(dataptr+3); for (int i = 0; i < modules.size(); i++) { DetectorModule& module = modules.getReference(i); if (module.gateChan == eventChannel) { if (eventId) module.isActive = true; else module.isActive = false; } } } }
void RecordControl::handleEvent(int eventType, MidiMessage& event, int) { const uint8* dataptr = event.getRawData(); int eventId = *(dataptr+2); int eventChannel = *(dataptr+3); //std::cout << "Received event with id=" << eventId << " and ch=" << eventChannel << std::endl; if (eventType == TTL && eventChannel == triggerChannel) { //std::cout << "Trigger!" << std::endl; const MessageManagerLock mmLock; if (eventId == 1) { getControlPanel()->setRecordState(true); } else { getControlPanel()->setRecordState(false); } } }
/** Checksum processors */ void CtrlrSysexProcessor::checksumRolandJp8080(const CtrlrSysexToken token, MidiMessage &m) { /* Since +5 is parameter value 1DH, F0 41 10 00 06 (model id) 12 (command if) 01 00 10 03 (address) 1D (data) ?? (checksum) F7 Next we calculate the checksum. 01H + 00H + 10H + 03H + 1DH = 1 + 0 + 16 + 3 + 29 = 49 (sum) 49 (total) 128 ÷ 0 (quotient) ... 49 (remainder) checksum = 128 - 49 (quotient) = 79 = 4FH This means that the message transmitted will be F0 41 10 00 06 12 01 00 10 03 1D 4F F7 */ const int startByte = token.getPosition() - token.getAdditionalData(); double chTotal = 0.0; uint8 *ptr = (uint8 *)m.getRawData(); for (int i=startByte; i<token.getPosition(); i++) { chTotal = chTotal + *(ptr+i); } const double remainder = fmod(chTotal, 128); const uint8 ch = (uint8)(remainder ? (128 - remainder) : 0); *(ptr+token.getPosition()) = ch; }