/[svn]/linuxsampler/trunk/src/drivers/midi/MidiInputPort.cpp

Diff of /linuxsampler/trunk/src/drivers/midi/MidiInputPort.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 880 by schoenebeck,
Tue Jun 27 22:57:37 2006 UTC
+revision 2559 by schoenebeck,
Sun May 18 17:38:25 2014 UTC
 Line 3
   *   LinuxSampler - modular, streaming capable sampler                     *
   *                                                                         *
   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
-  *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *
+  *   Copyright (C) 2005 - 2014 Christian Schoenebeck                       *
   *                                                                         *
   *   This program is free software; you can redistribute it and/or modify  *
   *   it under the terms of the GNU General Public License as published by  *
 Line 23
  #include "MidiInputPort.h"
+ #include "../../common/global_private.h"
+ #include "MidiInstrumentMapper.h"
  #include "../../Sampler.h"
  #include "../../engines/EngineFactory.h"
+ #include "VirtualMidiDevice.h"
+ #include <algorithm>
  namespace LinuxSampler {
-Line 71 
 namespace LinuxSampler {
+Line 76 
 namespace LinuxSampler {
      MidiInputPort::MidiInputPort(MidiInputDevice* pDevice, int portNumber)
          : MidiChannelMapReader(MidiChannelMap),
-           SysexListenersReader(SysexListeners) {
+           SysexListenersReader(SysexListeners),
+           virtualMidiDevicesReader(virtualMidiDevices),
+           noteOnVelocityFilterReader(noteOnVelocityFilter)
+     {
          this->pDevice = pDevice;
          this->portNumber = portNumber;
+         runningStatusBuf[0] = 0;
          Parameters["NAME"] = new ParameterName(this);
-         pPreviousProgramChangeEngineChannel = NULL;
      }
      MidiInputDevice* MidiInputPort::GetDevice() {
-Line 91 
 namespace LinuxSampler {
+Line 99 
 namespace LinuxSampler {
      }
      void MidiInputPort::DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel) {
+         if (Key > 127 || Velocity > 127 || MidiChannel > 16) return;
+         // apply velocity filter (if any)
+         const std::vector<uint8_t>& velocityFilter = noteOnVelocityFilterReader.Lock();
+         if (!velocityFilter.empty()) Velocity = velocityFilter[Velocity];
+         noteOnVelocityFilterReader.Unlock();
          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
          // dispatch event for engines listening to the same MIDI channel
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel);
          }
          // dispatch event for engines listening to ALL MIDI channels
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel);
          }
          MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendNoteOnToDevice(Key, Velocity);
+         virtualMidiDevicesReader.Unlock();
+     }
+     void MidiInputPort::DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {
+         if (Key > 127 || Velocity > 127 || MidiChannel > 16) return;
+         // apply velocity filter (if any)
+         const std::vector<uint8_t>& velocityFilter = noteOnVelocityFilterReader.Lock();
+         if (!velocityFilter.empty()) Velocity = velocityFilter[Velocity];
+         noteOnVelocityFilterReader.Unlock();
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel, FragmentPos);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel, FragmentPos);
+         }
+         MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendNoteOnToDevice(Key, Velocity);
+         virtualMidiDevicesReader.Unlock();
      }
      void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel) {
+         if (Key > 127 || Velocity > 127 || MidiChannel > 16) return;
          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
          // dispatch event for engines listening to the same MIDI channel
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel);
          }
          // dispatch event for engines listening to ALL MIDI channels
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel);
          }
          MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendNoteOffToDevice(Key, Velocity);
+         virtualMidiDevicesReader.Unlock();
+     }
+     void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {
+         if (Key > 127 || Velocity > 127 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel, FragmentPos);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel, FragmentPos);
+         }
+         MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendNoteOffToDevice(Key, Velocity);
+         virtualMidiDevicesReader.Unlock();
      }
      void MidiInputPort::DispatchPitchbend(int Pitch, uint MidiChannel) {
+         if (Pitch < -8192 || Pitch > 8191 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchPitchbend(int Pitch, uint MidiChannel, int32_t FragmentPos) {
+         if (Pitch < -8192 || Pitch > 8191 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel, FragmentPos);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel, FragmentPos);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchChannelPressure(uint8_t Value, uint MidiChannel) {
+         if (Value > 127 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendChannelPressure(Value, MidiChannel);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendChannelPressure(Value, MidiChannel);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchChannelPressure(uint8_t Value, uint MidiChannel, int32_t FragmentPos) {
+         if (Value > 127 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendChannelPressure(Value, MidiChannel, FragmentPos);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendChannelPressure(Value, MidiChannel, FragmentPos);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchPolyphonicKeyPressure(uint8_t Key, uint8_t Value, uint MidiChannel) {
+         if (Key > 127 || Value > 127 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPolyphonicKeyPressure(Key, Value, MidiChannel);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPolyphonicKeyPressure(Key, Value, MidiChannel);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchPolyphonicKeyPressure(uint8_t Key, uint8_t Value, uint MidiChannel, int32_t FragmentPos) {
+         if (Key > 127 || Value > 127 || MidiChannel > 16) return;
          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
          // dispatch event for engines listening to the same MIDI channel
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPolyphonicKeyPressure(Key, Value, MidiChannel, FragmentPos);
          }
          // dispatch event for engines listening to ALL MIDI channels
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendPolyphonicKeyPressure(Key, Value, MidiChannel, FragmentPos);
          }
          MidiChannelMapReader.Unlock();
      }
      void MidiInputPort::DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel) {
+         if (Controller > 128 || Value > 127 || MidiChannel > 16) return;
          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
          // dispatch event for engines listening to the same MIDI channel
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel);
          }
          // dispatch event for engines listening to ALL MIDI channels
          {
              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
-             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value);
+             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel);
          }
          MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendCCToDevice(Controller, Value);
+         virtualMidiDevicesReader.Unlock();
+     }
+     void MidiInputPort::DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel, int32_t FragmentPos) {
+         if (Controller > 128 || Value > 127 || MidiChannel > 16) return;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel, FragmentPos);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel, FragmentPos);
+         }
+         MidiChannelMapReader.Unlock();
+         // dispatch event to all low priority MIDI listeners
+         const std::vector<VirtualMidiDevice*>& listeners =
+             virtualMidiDevicesReader.Lock();
+         for (int i = 0; i < listeners.size(); ++i)
+             listeners[i]->SendCCToDevice(Controller, Value);
+         virtualMidiDevicesReader.Unlock();
      }
      void MidiInputPort::DispatchSysex(void* pData, uint Size) {
-Line 163 
 namespace LinuxSampler {
+Line 373 
 namespace LinuxSampler {
          // dispatch event to all engine instances
          std::set<Engine*>::iterator engineiter = allEngines.begin();
          std::set<Engine*>::iterator end        = allEngines.end();
-         for (; engineiter != end; engineiter++) (*engineiter)->SendSysex(pData, Size);
+         for (; engineiter != end; engineiter++) (*engineiter)->SendSysex(pData, Size, this);
          SysexListenersReader.Unlock();
      }
      void MidiInputPort::DispatchProgramChange(uint8_t Program, uint MidiChannel) {
+         if (Program > 127 || MidiChannel > 16) return;
          if (!pDevice || !pDevice->pSampler) {
              std::cerr << "MidiInputPort: ERROR, no sampler instance to handle program change."
                        << "This is a bug, please report it!\n" << std::flush;
              return;
          }
-         Sampler*        pSampler        = (Sampler*) pDevice->pSampler;
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
-         SamplerChannel* pSamplerChannel = pSampler->GetSamplerChannel(Program);
+         // dispatch event for engines listening to the same MIDI channel
-         if (!pSamplerChannel) return;
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendProgramChange(Program);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             for (; engineiter != end; engineiter++) (*engineiter)->SendProgramChange(Program);
+         }
+         MidiChannelMapReader.Unlock();
+     }
-         EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
+     void MidiInputPort::DispatchBankSelectMsb(uint8_t BankMSB, uint MidiChannel) {
-         if (!pEngineChannel) return;
+         if (BankMSB > 127 || MidiChannel > 16) return;
+         if (!pDevice || !pDevice->pSampler) {
+             std::cerr << "MidiInputPort: ERROR, no sampler instance to handle bank select MSB."
+                       << "This is a bug, please report it!\n" << std::flush;
+             return;
+         }
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             // according to the MIDI specs, a bank select should not alter the patch
+             for (; engineiter != end; engineiter++) (*engineiter)->SetMidiBankMsb(BankMSB);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             // according to the MIDI specs, a bank select should not alter the patch
+             for (; engineiter != end; engineiter++) (*engineiter)->SetMidiBankMsb(BankMSB);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     void MidiInputPort::DispatchBankSelectLsb(uint8_t BankLSB, uint MidiChannel) {
+         if (BankLSB > 127 || MidiChannel > 16) return;
+         if (!pDevice || !pDevice->pSampler) {
+             std::cerr << "MidiInputPort: ERROR, no sampler instance to handle bank select LSB."
+                       << "This is a bug, please report it!\n" << std::flush;
+             return;
+         }
+         const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
+         // dispatch event for engines listening to the same MIDI channel
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
+             // according to the MIDI specs, a bank select should not alter the patch
+             for (; engineiter != end; engineiter++) (*engineiter)->SetMidiBankLsb(BankLSB);
+         }
+         // dispatch event for engines listening to ALL MIDI channels
+         {
+             std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
+             std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
+             // according to the MIDI specs, a bank select should not alter the patch
+             for (; engineiter != end; engineiter++) (*engineiter)->SetMidiBankLsb(BankLSB);
+         }
+         MidiChannelMapReader.Unlock();
+     }
+     /**
+      * Handles the so called MIDI "running status" mode, which allows devices
+      * to reduce bandwidth (data reduction).
+      *
+      * If the passed in MIDI data is regular MIDI data, this method will simply
+      * return the original data pointer and just stores the status byte for
+      * potential "running status" event eventually coming next.
+      *
+      * If the passed in MIDI data however seems to be in "running status" mode,
+      * this method will return another buffer, which allows the MIDI parser
+      * to handle the MIDI data as usually with "normal" MIDI data.
+      */
+     uint8_t* MidiInputPort::handleRunningStatus(uint8_t* pData) {
+         if ((pData[0] & 0x80) || !runningStatusBuf[0]) {
+             // store status byte for eventual "running status" in next event
+             if (pData[0] & 0x80) {
+                 if (pData[0] < 0xf0) {
+                     // "running status" is only allowed for channel messages
+                     runningStatusBuf[0] = pData[0];
+                 } else if (pData[0] < 0xf8) {
+                     // "system common" messages (0xf0..0xf7) shall reset any running
+                     // status, however "realtime" messages (0xf8..0xff) shall be
+                     // ignored here
+                     runningStatusBuf[0] = 0;
+                 }
+             }
+             // it's either a regular status byte, or some invalid "running status"
+             return pData;
+         } else { // "running status" mode ...
+             const uint8_t type = runningStatusBuf[0] & 0xf0;
+             const int size = (type == 0xc0 || type == 0xd0) ? 1 : 2; // only program change & channel pressure have 1 data bytes
+             memcpy(&runningStatusBuf[1], pData, size);
+             return runningStatusBuf;
+         }
+     }
-         // disconnect from the engine channel which was connected by the last PC event
+     void MidiInputPort::DispatchRaw(uint8_t* pData) {
-         if (pPreviousProgramChangeEngineChannel)
+         pData = handleRunningStatus(pData);
-             Disconnect(pPreviousProgramChangeEngineChannel);
+         uint8_t channel = pData[0] & 0x0f;
+         switch (pData[0] & 0xf0) {
+         case 0x80:
+             DispatchNoteOff(pData[1], pData[2], channel);
+             break;
+         case 0x90:
+             if (pData[2]) {
+                 DispatchNoteOn(pData[1], pData[2], channel);
+             } else {
+                 DispatchNoteOff(pData[1], pData[2], channel);
+             }
+             break;
+         case 0xA0:
+             DispatchPolyphonicKeyPressure(pData[1], pData[2], channel);
+             break;
+         case 0xb0:
+             if (pData[1] == 0) {
+                 DispatchBankSelectMsb(pData[2], channel);
+             } else if (pData[1] == 32) {
+                 DispatchBankSelectLsb(pData[2], channel);
+             }
+             DispatchControlChange(pData[1], pData[2], channel);
+             break;
+         case 0xc0:
+             DispatchProgramChange(pData[1], channel);
+             break;
+         case 0xd0:
+             DispatchChannelPressure(pData[1], channel);
+             break;
+         case 0xe0:
+             DispatchPitchbend((pData[1] | pData[2] << 7) - 8192, channel);
+             break;
+         }
+     }
-         // now connect to the new engine channel and remember it
+     void MidiInputPort::DispatchRaw(uint8_t* pData, int32_t FragmentPos) {
-         try {
+         pData = handleRunningStatus(pData);
-             Connect(pEngineChannel, (midi_chan_t) MidiChannel);
-             pPreviousProgramChangeEngineChannel = pEngineChannel;
+         uint8_t channel = pData[0] & 0x0f;
+         switch (pData[0] & 0xf0) {
+         case 0x80:
+             DispatchNoteOff(pData[1], pData[2], channel, FragmentPos);
+             break;
+         case 0x90:
+             if (pData[2]) {
+                 DispatchNoteOn(pData[1], pData[2], channel, FragmentPos);
+             } else {
+                 DispatchNoteOff(pData[1], pData[2], channel, FragmentPos);
+             }
+             break;
+         case 0xA0:
+             DispatchPolyphonicKeyPressure(pData[1], pData[2], channel, FragmentPos);
+             break;
+         case 0xb0:
+             if (pData[1] == 0) {
+                 DispatchBankSelectMsb(pData[2], channel);
+             } else if (pData[1] == 32) {
+                 DispatchBankSelectLsb(pData[2], channel);
+             }
+             DispatchControlChange(pData[1], pData[2], channel, FragmentPos);
+             break;
+         case 0xc0:
+             DispatchProgramChange(pData[1], channel);
+             break;
+         case 0xd0:
+             DispatchChannelPressure(pData[1], channel, FragmentPos);
+             break;
+         case 0xe0:
+             DispatchPitchbend((pData[1] | pData[2] << 7) - 8192, channel, FragmentPos);
+             break;
+         }
+     }
+     void MidiInputPort::SetNoteOnVelocityFilter(const std::vector<uint8_t>& filter) {
+         if (filter.size() != 128 && filter.size() != 0)
+             throw MidiInputException("Note on velocity filter must be either of size 128 or 0");
+         // check the value range of the filter
+         if (!filter.empty())
+             for (int i = 0; i < 128; i++)
+                 if (filter[i] > 127)
+                     throw MidiInputException("Invalid note on velocity filter, values must be in range 0 .. 127");
+         // apply new filter ...
+         LockGuard lock(noteOnVelocityFilterMutex);
+         // double buffer ... double work ...
+         {
+             std::vector<uint8_t>& config =
+                 noteOnVelocityFilter.GetConfigForUpdate();
+             config = filter;
+         }
+         {
+             std::vector<uint8_t>& config =
+                 noteOnVelocityFilter.SwitchConfig();
+             config = filter;
          }
-         catch (...) { /* NOOP */ }
      }
      void MidiInputPort::Connect(EngineChannel* pEngineChannel, midi_chan_t MidiChannel) {
-Line 198 
 namespace LinuxSampler {
+Line 593 
 namespace LinuxSampler {
              throw MidiInputException("MIDI channel index out of bounds");
          // first check if desired connection is already established
-         MidiChannelMapMutex.Lock();
+         {
-         MidiChannelMap_t& midiChannelMap = MidiChannelMap.GetConfigForUpdate();
+             LockGuard lock(MidiChannelMapMutex);
-         bool bAlreadyDone = midiChannelMap[MidiChannel].count(pEngineChannel);
+             MidiChannelMap_t& midiChannelMap = MidiChannelMap.GetConfigForUpdate();
-         MidiChannelMapMutex.Unlock();
+             if (midiChannelMap[MidiChannel].count(pEngineChannel)) return;
-         if (bAlreadyDone) return;
+         }
          // remove all other connections of that engine channel (if any)
          Disconnect(pEngineChannel);
          // register engine channel on the desired MIDI channel
-         MidiChannelMapMutex.Lock();
+         {
-         MidiChannelMap.GetConfigForUpdate()[MidiChannel].insert(pEngineChannel);
+             LockGuard lock(MidiChannelMapMutex);
-         MidiChannelMap.SwitchConfig()[MidiChannel].insert(pEngineChannel);
+             MidiChannelMap.GetConfigForUpdate()[MidiChannel].insert(pEngineChannel);
-         MidiChannelMapMutex.Unlock();
+             MidiChannelMap.SwitchConfig()[MidiChannel].insert(pEngineChannel);
+         }
          // inform engine channel about this connection
-         pEngineChannel->Connect(this, MidiChannel);
+         pEngineChannel->Connect(this);
+         if (pEngineChannel->MidiChannel() != MidiChannel)
+             pEngineChannel->SetMidiChannel(MidiChannel);
          // mark engine channel as changed
          pEngineChannel->StatusChanged(true);
-Line 226 
 namespace LinuxSampler {
+Line 624 
 namespace LinuxSampler {
          bool bChannelFound = false;
          // unregister engine channel from all MIDI channels
-         MidiChannelMapMutex.Lock();
          try {
+             LockGuard lock(MidiChannelMapMutex);
              {
                  MidiChannelMap_t& midiChannelMap = MidiChannelMap.GetConfigForUpdate();
                  for (int i = 0; i <= 16; i++) {
-Line 245 
 namespace LinuxSampler {
+Line 643 
 namespace LinuxSampler {
              }
          }
          catch(...) { /* NOOP */ }
-         MidiChannelMapMutex.Unlock();
          // inform engine channel about the disconnection (if there is one)
-         if (bChannelFound) pEngineChannel->DisconnectMidiInputPort();
+         if (bChannelFound) pEngineChannel->Disconnect(this);
          // mark engine channel as changed
          pEngineChannel->StatusChanged(true);
-Line 267 
 namespace LinuxSampler {
+Line 664 
 namespace LinuxSampler {
          return count;
      }
+     void MidiInputPort::Connect(VirtualMidiDevice* pDevice) {
+         LockGuard lock(virtualMidiDevicesMutex);
+         // double buffer ... double work ...
+         {
+             std::vector<VirtualMidiDevice*>& devices =
+                 virtualMidiDevices.GetConfigForUpdate();
+             devices.push_back(pDevice);
+         }
+         {
+             std::vector<VirtualMidiDevice*>& devices =
+                 virtualMidiDevices.SwitchConfig();
+             devices.push_back(pDevice);
+         }
+     }
+     void MidiInputPort::Disconnect(VirtualMidiDevice* pDevice) {
+         LockGuard lock(virtualMidiDevicesMutex);
+         // double buffer ... double work ...
+         {
+             std::vector<VirtualMidiDevice*>& devices =
+                 virtualMidiDevices.GetConfigForUpdate();
+             devices.erase(std::find(devices.begin(), devices.end(), pDevice));
+         }
+         {
+             std::vector<VirtualMidiDevice*>& devices =
+                 virtualMidiDevices.SwitchConfig();
+             devices.erase(std::find(devices.begin(), devices.end(), pDevice));
+         }
+     }
+     int MidiInputPort::expectedEventSize(unsigned char byte) {
+         if (!(byte & 0x80) && runningStatusBuf[0])
+             byte = runningStatusBuf[0]; // "running status" mode
+         if (byte < 0x80) return -1; // not a valid status byte
+         if (byte < 0xC0) return 3; // note on/off, note pressure, control change
+         if (byte < 0xE0) return 2; // program change, channel pressure
+         if (byte < 0xF0) return 3; // pitch wheel
+         if (byte == 0xF0) return -1; // sysex message (variable size)
+         if (byte == 0xF1) return 2; // time code per quarter frame
+         if (byte == 0xF2) return 3; // sys. common song position pointer
+         if (byte == 0xF3) return 2; // sys. common song select
+         if (byte == 0xF4) return -1; // sys. common undefined / reserved
+         if (byte == 0xF5) return -1; // sys. common undefined / reserved
+         return 1; // tune request, end of SysEx, system real-time events
+     }
  } // namespace LinuxSampler

 Legend:



Removed from v.880
 


changed lines


 
Added in v.2559
 Legend:



Removed from v.880
 


changed lines


 
Added in v.2559
-Removed from v.880
+Added in v.2559

	ViewVC Help
Powered by ViewVC