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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1135 by iliev, Thu Mar 29 09:40:45 2007 UTC revision 2317 by persson, Sun Feb 19 12:13:19 2012 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6   *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *   *   Copyright (C) 2005 - 2012 Christian Schoenebeck                       *
7   *                                                                         *   *                                                                         *
8   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 23  Line 23 
23    
24  #include "MidiInputPort.h"  #include "MidiInputPort.h"
25    
26    #include "../../common/global_private.h"
27  #include "MidiInstrumentMapper.h"  #include "MidiInstrumentMapper.h"
28  #include "../../Sampler.h"  #include "../../Sampler.h"
29  #include "../../engines/EngineFactory.h"  #include "../../engines/EngineFactory.h"
30    #include "VirtualMidiDevice.h"
31    
32    #include <algorithm>
33    
34  namespace LinuxSampler {  namespace LinuxSampler {
35    
# Line 72  namespace LinuxSampler { Line 76  namespace LinuxSampler {
76    
77      MidiInputPort::MidiInputPort(MidiInputDevice* pDevice, int portNumber)      MidiInputPort::MidiInputPort(MidiInputDevice* pDevice, int portNumber)
78          : MidiChannelMapReader(MidiChannelMap),          : MidiChannelMapReader(MidiChannelMap),
79            SysexListenersReader(SysexListeners) {            SysexListenersReader(SysexListeners),
80              virtualMidiDevicesReader(virtualMidiDevices) {
81          this->pDevice = pDevice;          this->pDevice = pDevice;
82          this->portNumber = portNumber;          this->portNumber = portNumber;
83          Parameters["NAME"] = new ParameterName(this);          Parameters["NAME"] = new ParameterName(this);
# Line 97  namespace LinuxSampler { Line 102  namespace LinuxSampler {
102          {          {
103              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
104              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
105              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel);
106          }          }
107          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
108          {          {
109              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
110              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
111              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel);
112          }          }
113          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
114    
115            // dispatch event to all low priority MIDI listeners
116            const std::vector<VirtualMidiDevice*>& listeners =
117                virtualMidiDevicesReader.Lock();
118            for (int i = 0; i < listeners.size(); ++i)
119                listeners[i]->SendNoteOnToDevice(Key, Velocity);
120            virtualMidiDevicesReader.Unlock();
121      }      }
122    
123      void MidiInputPort::DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {      void MidiInputPort::DispatchNoteOn(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {
# Line 115  namespace LinuxSampler { Line 127  namespace LinuxSampler {
127          {          {
128              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
129              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
130              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel, FragmentPos);
131          }          }
132          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
133          {          {
134              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
135              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
136              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOn(Key, Velocity, MidiChannel, FragmentPos);
137          }          }
138          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
139    
140            // dispatch event to all low priority MIDI listeners
141            const std::vector<VirtualMidiDevice*>& listeners =
142                virtualMidiDevicesReader.Lock();
143            for (int i = 0; i < listeners.size(); ++i)
144                listeners[i]->SendNoteOnToDevice(Key, Velocity);
145            virtualMidiDevicesReader.Unlock();
146      }      }
147    
148      void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel) {      void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel) {
# Line 133  namespace LinuxSampler { Line 152  namespace LinuxSampler {
152          {          {
153              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
154              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
155              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel);
156          }          }
157          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
158          {          {
159              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
160              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
161              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel);
162          }          }
163          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
164    
165            // dispatch event to all low priority MIDI listeners
166            const std::vector<VirtualMidiDevice*>& listeners =
167                virtualMidiDevicesReader.Lock();
168            for (int i = 0; i < listeners.size(); ++i)
169                listeners[i]->SendNoteOffToDevice(Key, Velocity);
170            virtualMidiDevicesReader.Unlock();
171      }      }
172    
173      void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {      void MidiInputPort::DispatchNoteOff(uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos) {
# Line 151  namespace LinuxSampler { Line 177  namespace LinuxSampler {
177          {          {
178              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
179              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
180              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel, FragmentPos);
181          }          }
182          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
183          {          {
184              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
185              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
186              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendNoteOff(Key, Velocity, MidiChannel, FragmentPos);
187          }          }
188          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
189    
190            // dispatch event to all low priority MIDI listeners
191            const std::vector<VirtualMidiDevice*>& listeners =
192                virtualMidiDevicesReader.Lock();
193            for (int i = 0; i < listeners.size(); ++i)
194                listeners[i]->SendNoteOffToDevice(Key, Velocity);
195            virtualMidiDevicesReader.Unlock();
196      }      }
197    
198      void MidiInputPort::DispatchPitchbend(int Pitch, uint MidiChannel) {      void MidiInputPort::DispatchPitchbend(int Pitch, uint MidiChannel) {
# Line 169  namespace LinuxSampler { Line 202  namespace LinuxSampler {
202          {          {
203              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
204              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
205              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch);              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel);
206          }          }
207          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
208          {          {
209              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
210              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
211              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch);              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel);
212          }          }
213          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
214      }      }
# Line 187  namespace LinuxSampler { Line 220  namespace LinuxSampler {
220          {          {
221              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
222              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
223              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel, FragmentPos);
224          }          }
225          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
226          {          {
227              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
228              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
229              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendPitchbend(Pitch, MidiChannel, FragmentPos);
230          }          }
231          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
232      }      }
# Line 205  namespace LinuxSampler { Line 238  namespace LinuxSampler {
238          {          {
239              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
240              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
241              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value);              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel);
242          }          }
243          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
244          {          {
245              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
246              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
247              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value);              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel);
248          }          }
249          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
250            
251            // dispatch event to all low priority MIDI listeners
252            const std::vector<VirtualMidiDevice*>& listeners =
253                virtualMidiDevicesReader.Lock();
254            for (int i = 0; i < listeners.size(); ++i)
255                listeners[i]->SendCCToDevice(Controller, Value);
256            virtualMidiDevicesReader.Unlock();
257      }      }
258    
259      void MidiInputPort::DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel, int32_t FragmentPos) {      void MidiInputPort::DispatchControlChange(uint8_t Controller, uint8_t Value, uint MidiChannel, int32_t FragmentPos) {
# Line 223  namespace LinuxSampler { Line 263  namespace LinuxSampler {
263          {          {
264              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
265              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
266              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel, FragmentPos);
267          }          }
268          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
269          {          {
270              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
271              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
272              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, FragmentPos);              for (; engineiter != end; engineiter++) (*engineiter)->SendControlChange(Controller, Value, MidiChannel, FragmentPos);
273          }          }
274          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
275            
276            // dispatch event to all low priority MIDI listeners
277            const std::vector<VirtualMidiDevice*>& listeners =
278                virtualMidiDevicesReader.Lock();
279            for (int i = 0; i < listeners.size(); ++i)
280                listeners[i]->SendCCToDevice(Controller, Value);
281            virtualMidiDevicesReader.Unlock();
282      }      }
283    
284      void MidiInputPort::DispatchSysex(void* pData, uint Size) {      void MidiInputPort::DispatchSysex(void* pData, uint Size) {
# Line 239  namespace LinuxSampler { Line 286  namespace LinuxSampler {
286          // dispatch event to all engine instances          // dispatch event to all engine instances
287          std::set<Engine*>::iterator engineiter = allEngines.begin();          std::set<Engine*>::iterator engineiter = allEngines.begin();
288          std::set<Engine*>::iterator end        = allEngines.end();          std::set<Engine*>::iterator end        = allEngines.end();
289          for (; engineiter != end; engineiter++) (*engineiter)->SendSysex(pData, Size);          for (; engineiter != end; engineiter++) (*engineiter)->SendSysex(pData, Size, this);
290          SysexListenersReader.Unlock();          SysexListenersReader.Unlock();
291      }      }
292    
293      void MidiInputPort::DispatchProgramChange(uint8_t Program, uint MidiChannel) {      void MidiInputPort::DispatchProgramChange(uint8_t Program, uint MidiChannel) {
         dmsg(1,("Received MIDI program change (prog=%d,ch=%d)\n",Program,MidiChannel));  
294          if (Program > 127 || MidiChannel > 16) return;          if (Program > 127 || MidiChannel > 16) return;
295          if (!pDevice || !pDevice->pSampler) {          if (!pDevice || !pDevice->pSampler) {
296              std::cerr << "MidiInputPort: ERROR, no sampler instance to handle program change."              std::cerr << "MidiInputPort: ERROR, no sampler instance to handle program change."
297                        << "This is a bug, please report it!\n" << std::flush;                        << "This is a bug, please report it!\n" << std::flush;
298              return;              return;
299          }          }
         std::vector<int> maps = MidiInstrumentMapper::Maps();  
         if (maps.empty()) return;  
300    
301          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();          const MidiChannelMap_t& midiChannelMap = MidiChannelMapReader.Lock();
302          // dispatch event for engines listening to the same MIDI channel          // dispatch event for engines listening to the same MIDI channel
303          {          {
304              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[MidiChannel].begin();
305              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[MidiChannel].end();
306              for (; engineiter != end; engineiter++) {              for (; engineiter != end; engineiter++) (*engineiter)->SendProgramChange(Program);
                 (*engineiter)->SetMidiProgram(Program);  
                 if ((*engineiter)->UsesNoMidiInstrumentMap()) continue;  
                 if (MidiInstrumentMapper::GetMapCount() == 0) continue;  
                 // retrieve the MIDI instrument map this engine channel is assigned to  
                 int iMapID = ((*engineiter)->UsesDefaultMidiInstrumentMap())  
                     ? MidiInstrumentMapper::GetDefaultMap() /*default*/ : (*engineiter)->GetMidiInstrumentMap();  
                 // is there an entry for this MIDI bank&prog pair in that map?  
                 midi_prog_index_t midiIndex;  
                 midiIndex.midi_bank_msb = (*engineiter)->GetMidiBankMsb();  
                 midiIndex.midi_bank_lsb = (*engineiter)->GetMidiBankLsb();  
                 midiIndex.midi_prog     = (*engineiter)->GetMidiProgram();  
                 optional<MidiInstrumentMapper::entry_t> mapping =  
                     MidiInstrumentMapper::GetEntry(iMapID, midiIndex);  
                 if (mapping) { // if mapping exists ...  
                     InstrumentManager::instrument_id_t id;  
                     id.FileName = mapping->InstrumentFile;  
                     id.Index    = mapping->InstrumentIndex;  
                     //TODO: we should switch the engine type here  
                     InstrumentManager::LoadInstrumentInBackground(id, *engineiter);  
                     (*engineiter)->Volume(mapping->Volume);  
                 }  
             }  
307          }          }
308          // dispatch event for engines listening to ALL MIDI channels          // dispatch event for engines listening to ALL MIDI channels
309          {          {
310              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();              std::set<EngineChannel*>::iterator engineiter = midiChannelMap[midi_chan_all].begin();
311              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();              std::set<EngineChannel*>::iterator end        = midiChannelMap[midi_chan_all].end();
312              for (; engineiter != end; engineiter++) {              for (; engineiter != end; engineiter++) (*engineiter)->SendProgramChange(Program);
                 (*engineiter)->SetMidiProgram(Program);  
                 if ((*engineiter)->UsesNoMidiInstrumentMap()) continue;  
                 if (MidiInstrumentMapper::GetMapCount() == 0) continue;  
                 // retrieve the MIDI instrument map this engine channel is assigned to  
                 int iMapID = ((*engineiter)->UsesDefaultMidiInstrumentMap())  
                     ? MidiInstrumentMapper::GetDefaultMap() /*default*/ : (*engineiter)->GetMidiInstrumentMap();  
                 // is there an entry for this MIDI bank&prog pair in that map?  
                 midi_prog_index_t midiIndex;  
                 midiIndex.midi_bank_msb = (*engineiter)->GetMidiBankMsb();  
                 midiIndex.midi_bank_lsb = (*engineiter)->GetMidiBankLsb();  
                 midiIndex.midi_prog     = (*engineiter)->GetMidiProgram();  
                 optional<MidiInstrumentMapper::entry_t> mapping =  
                     MidiInstrumentMapper::GetEntry(iMapID, midiIndex);  
                 if (mapping) { // if mapping exists ...  
                     InstrumentManager::instrument_id_t id;  
                     id.FileName = mapping->InstrumentFile;  
                     id.Index    = mapping->InstrumentIndex;  
                     //TODO: we should switch the engine type here  
                     InstrumentManager::LoadInstrumentInBackground(id, *engineiter);  
                     (*engineiter)->Volume(mapping->Volume);  
                 }  
             }  
313          }          }
314          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
315      }      }
# Line 364  namespace LinuxSampler { Line 364  namespace LinuxSampler {
364          MidiChannelMapReader.Unlock();          MidiChannelMapReader.Unlock();
365      }      }
366    
367        void MidiInputPort::DispatchRaw(uint8_t* pData) {
368            uint8_t channel = pData[0] & 0x0f;
369            switch (pData[0] & 0xf0) {
370            case 0x80:
371                DispatchNoteOff(pData[1], pData[2], channel);
372                break;
373            case 0x90:
374                if (pData[2]) {
375                    DispatchNoteOn(pData[1], pData[2], channel);
376                } else {
377                    DispatchNoteOff(pData[1], pData[2], channel);
378                }
379                break;
380            case 0xb0:
381                if (pData[1] == 0) {
382                    DispatchBankSelectMsb(pData[2], channel);
383                } else if (pData[1] == 32) {
384                    DispatchBankSelectLsb(pData[2], channel);
385                }
386                DispatchControlChange(pData[1], pData[2], channel);
387                break;
388            case 0xc0:
389                DispatchProgramChange(pData[1], channel);
390                break;
391            case 0xd0:
392                DispatchControlChange(128, pData[1], channel);
393                break;
394            case 0xe0:
395                DispatchPitchbend((pData[1] | pData[2] << 7) - 8192, channel);
396                break;
397            }
398        }
399    
400        void MidiInputPort::DispatchRaw(uint8_t* pData, int32_t FragmentPos) {
401            uint8_t channel = pData[0] & 0x0f;
402            switch (pData[0] & 0xf0) {
403            case 0x80:
404                DispatchNoteOff(pData[1], pData[2], channel, FragmentPos);
405                break;
406            case 0x90:
407                if (pData[2]) {
408                    DispatchNoteOn(pData[1], pData[2], channel, FragmentPos);
409                } else {
410                    DispatchNoteOff(pData[1], pData[2], channel, FragmentPos);
411                }
412                break;
413            case 0xb0:
414                if (pData[1] == 0) {
415                    DispatchBankSelectMsb(pData[2], channel);
416                } else if (pData[1] == 32) {
417                    DispatchBankSelectLsb(pData[2], channel);
418                }
419                DispatchControlChange(pData[1], pData[2], channel, FragmentPos);
420                break;
421            case 0xc0:
422                DispatchProgramChange(pData[1], channel);
423                break;
424            case 0xd0:
425                DispatchControlChange(128, pData[1], channel, FragmentPos);
426                break;
427            case 0xe0:
428                DispatchPitchbend((pData[1] | pData[2] << 7) - 8192, channel, FragmentPos);
429                break;
430            }
431        }
432    
433      void MidiInputPort::Connect(EngineChannel* pEngineChannel, midi_chan_t MidiChannel) {      void MidiInputPort::Connect(EngineChannel* pEngineChannel, midi_chan_t MidiChannel) {
434          if (MidiChannel < 0 || MidiChannel > 16)          if (MidiChannel < 0 || MidiChannel > 16)
435              throw MidiInputException("MIDI channel index out of bounds");              throw MidiInputException("MIDI channel index out of bounds");
# Line 438  namespace LinuxSampler { Line 504  namespace LinuxSampler {
504          return count;          return count;
505      }      }
506    
507        void MidiInputPort::Connect(VirtualMidiDevice* pDevice) {
508            virtualMidiDevicesMutex.Lock();
509            // double buffer ... double work ...
510            {
511                std::vector<VirtualMidiDevice*>& devices =
512                    virtualMidiDevices.GetConfigForUpdate();
513                devices.push_back(pDevice);
514            }
515            {
516                std::vector<VirtualMidiDevice*>& devices =
517                    virtualMidiDevices.SwitchConfig();
518                devices.push_back(pDevice);
519            }
520            virtualMidiDevicesMutex.Unlock();
521        }
522    
523        void MidiInputPort::Disconnect(VirtualMidiDevice* pDevice) {
524            virtualMidiDevicesMutex.Lock();
525            // double buffer ... double work ...
526            {
527                std::vector<VirtualMidiDevice*>& devices =
528                    virtualMidiDevices.GetConfigForUpdate();
529                devices.erase(std::find(devices.begin(), devices.end(), pDevice));
530            }
531            {
532                std::vector<VirtualMidiDevice*>& devices =
533                    virtualMidiDevices.SwitchConfig();
534                devices.erase(std::find(devices.begin(), devices.end(), pDevice));
535            }
536            virtualMidiDevicesMutex.Unlock();
537        }
538    
539  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.1135  
changed lines
  Added in v.2317
  ViewVC Help
Powered by ViewVC