Esempio n. 1
0
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);
    }
Esempio n. 3
0
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:[----]");
}
Esempio n. 4
0
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);
}
Esempio n. 6
0
const MemoryBlock CtrlrMIDITransaction::getDataFromResponse(const MidiMessage &messageToExtractFrom)
{
	MemoryBlock returnData;
	MemoryBlock temp(messageToExtractFrom.getRawData(), messageToExtractFrom.getRawDataSize());

	returnData.copyFrom (temp.getData(), getResponsePrefixLength(), getResponseDataLength());
	return (returnData);
}
Esempio n. 7
0
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);
}
Esempio n. 8
0
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());
    }
}
Esempio n. 9
0
const String getMidiChannel(const MidiMessage &m)
{
	if (m.getChannel() > 0)
	{
		return (String::formatted (" Ch:[%2d]", m.getChannel()));
	}

	return (" Ch:[--]");
}
Esempio n. 10
0
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");
        }
    }
}
Esempio n. 12
0
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(&timestamp, dataptr +6+ len, 8); 
	
}
Esempio n. 13
0
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;
   }

}
Esempio n. 14
0
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;
   }

}
Esempio n. 15
0
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);
}
Esempio n. 16
0
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));
}
Esempio n. 17
0
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);
}
Esempio n. 18
0
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;
         }
      }
   }
}
Esempio n. 19
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;
}
Esempio n. 20
0
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);
            }
        }
    }
}
Esempio n. 22
0
//==============================================================================
void MPEZoneLayout::processNextMidiEvent (const MidiMessage& message)
{
    if (! message.isController())
        return;

    MidiRPNMessage rpn;

    if (rpnDetector.parseControllerMessage (message.getChannel(),
                                            message.getControllerNumber(),
                                            message.getControllerValue(),
                                            rpn))
    {
        processRpnMessage (rpn);
    }
}
Esempio n. 23
0
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);
}
Esempio n. 24
0
//==============================================================================
void MainContentComponent::handleIncomingMidiMessage (MidiInput* /*source*/, const MidiMessage &message)
{
    // This is called on the MIDI thread

    if (message.isNoteOnOrOff())
        postMessage (new MidiCallbackMessage (message));
}
Esempio n. 25
0
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);
            }
        }

    }

}
Esempio n. 26
0
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);
    }
}
Esempio n. 28
0
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;
            }
        }

    }

}
Esempio n. 29
0
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);
        }


    }

}
Esempio n. 30
0
/** 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;
}