/[svn]/linuxsampler/trunk/src/Sampler.cpp
ViewVC logotype

Annotation of /linuxsampler/trunk/src/Sampler.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1130 - (hide annotations) (download)
Sun Mar 25 18:59:14 2007 UTC (17 years ago) by iliev
File size: 23266 byte(s)
* Implemented new, improved notification system

1 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 61 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 1008 * Copyright (C) 2005 - 2007 Christian Schoenebeck *
7 schoenebeck 53 * *
8 schoenebeck 1008 * This library is free software; you can redistribute it and/or modify *
9 schoenebeck 53 * it under the terms of the GNU General Public License as published by *
10     * the Free Software Foundation; either version 2 of the License, or *
11     * (at your option) any later version. *
12     * *
13 schoenebeck 1008 * This library is distributed in the hope that it will be useful, *
14 schoenebeck 53 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16     * GNU General Public License for more details. *
17     * *
18     * You should have received a copy of the GNU General Public License *
19 schoenebeck 1008 * along with this library; if not, write to the Free Software *
20 schoenebeck 53 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21     * MA 02111-1307 USA *
22     ***************************************************************************/
23    
24 schoenebeck 123 #include <sstream>
25    
26 schoenebeck 53 #include "Sampler.h"
27    
28 iliev 778 #include "engines/EngineFactory.h"
29 schoenebeck 411 #include "engines/EngineChannelFactory.h"
30 schoenebeck 203 #include "drivers/audio/AudioOutputDeviceFactory.h"
31     #include "drivers/midi/MidiInputDeviceFactory.h"
32 schoenebeck 1008 #include "drivers/midi/MidiInstrumentMapper.h"
33 schoenebeck 53
34     namespace LinuxSampler {
35    
36     // ******************************************************************
37     // * SamplerChannel
38    
39     SamplerChannel::SamplerChannel(Sampler* pS) {
40     pSampler = pS;
41 schoenebeck 411 pEngineChannel = NULL;
42 schoenebeck 675 pAudioOutputDevice = NULL;
43 capela 159 pMidiInputDevice = NULL;
44 schoenebeck 675 iMidiPort = 0;
45     midiChannel = midi_chan_all;
46 schoenebeck 53 iIndex = -1;
47     }
48    
49     SamplerChannel::~SamplerChannel() {
50 schoenebeck 411 if (pEngineChannel) {
51 persson 840 Engine* engine = pEngineChannel->GetEngine();
52     if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(engine);
53    
54 schoenebeck 675 MidiInputPort* pMidiInputPort = (pEngineChannel) ? pEngineChannel->GetMidiInputPort() : __GetMidiInputDevicePort(GetMidiInputChannel());
55 schoenebeck 411 if (pMidiInputPort) pMidiInputPort->Disconnect(pEngineChannel);
56 schoenebeck 420 if (pEngineChannel) {
57     if (pAudioOutputDevice) pEngineChannel->DisconnectAudioOutputDevice();
58 schoenebeck 660 EngineChannelFactory::Destroy(pEngineChannel);
59 persson 840
60     // reconnect engine if it still exists
61     const std::set<Engine*>& engines = EngineFactory::EngineInstances();
62     if (engines.find(engine) != engines.end()) pAudioOutputDevice->Connect(engine);
63 schoenebeck 420 }
64 schoenebeck 53 }
65     }
66    
67 schoenebeck 880 void SamplerChannel::SetEngineType(String EngineType) throw (Exception) {
68 schoenebeck 411 dmsg(2,("SamplerChannel: Assigning engine type..."));
69 schoenebeck 53
70 schoenebeck 411 // create new engine channel
71     EngineChannel* pNewEngineChannel = EngineChannelFactory::Create(EngineType);
72 schoenebeck 880 if (!pNewEngineChannel) throw Exception("Unknown engine type");
73 schoenebeck 53
74 schoenebeck 660 //FIXME: hack to allow fast retrieval of engine channel's sampler channel index
75     pNewEngineChannel->iSamplerChannelIndex = Index();
76    
77 capela 159 // dereference midi input port.
78 schoenebeck 675 MidiInputPort* pMidiInputPort = __GetMidiInputDevicePort(GetMidiInputPort());
79     // disconnect old engine channel
80 schoenebeck 411 if (pEngineChannel) {
81 persson 840 Engine* engine = pEngineChannel->GetEngine();
82     if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(engine);
83    
84 schoenebeck 411 if (pMidiInputPort) pMidiInputPort->Disconnect(pEngineChannel);
85 schoenebeck 412 if (pAudioOutputDevice) pEngineChannel->DisconnectAudioOutputDevice();
86 schoenebeck 660 EngineChannelFactory::Destroy(pEngineChannel);
87 persson 840
88     // reconnect engine if it still exists
89     const std::set<Engine*>& engines = EngineFactory::EngineInstances();
90     if (engines.find(engine) != engines.end()) pAudioOutputDevice->Connect(engine);
91 schoenebeck 53 }
92    
93 schoenebeck 411 // connect new engine channel
94 schoenebeck 412 if (pAudioOutputDevice) {
95     pNewEngineChannel->Connect(pAudioOutputDevice);
96     pAudioOutputDevice->Connect(pNewEngineChannel->GetEngine());
97     }
98 persson 846 if (pMidiInputPort) pMidiInputPort->Connect(pNewEngineChannel, GetMidiInputChannel());
99 schoenebeck 675 pEngineChannel = pNewEngineChannel;
100    
101     // from now on get MIDI device and port from EngineChannel object
102     this->pMidiInputDevice = NULL;
103     this->iMidiPort = 0;
104    
105 iliev 730 pEngineChannel->StatusChanged(true);
106 iliev 1130 fireEngineChanged();
107 schoenebeck 64 dmsg(2,("OK\n"));
108 schoenebeck 53 }
109    
110 schoenebeck 123 void SamplerChannel::SetAudioOutputDevice(AudioOutputDevice* pDevice) {
111 iliev 960 if(pAudioOutputDevice == pDevice) return;
112    
113 schoenebeck 53 // disconnect old device
114 persson 840 if (pAudioOutputDevice && pEngineChannel) {
115     Engine* engine = pEngineChannel->GetEngine();
116     pAudioOutputDevice->Disconnect(engine);
117    
118     pEngineChannel->DisconnectAudioOutputDevice();
119    
120     // reconnect engine if it still exists
121     const std::set<Engine*>& engines = EngineFactory::EngineInstances();
122     if (engines.find(engine) != engines.end()) pAudioOutputDevice->Connect(engine);
123     }
124    
125 schoenebeck 53 // connect new device
126     pAudioOutputDevice = pDevice;
127 schoenebeck 412 if (pEngineChannel) {
128     pEngineChannel->Connect(pAudioOutputDevice);
129     pAudioOutputDevice->Connect(pEngineChannel->GetEngine());
130     }
131 schoenebeck 53 }
132    
133 capela 159 void SamplerChannel::SetMidiInputDevice(MidiInputDevice* pDevice) {
134 schoenebeck 675 SetMidiInput(pDevice, 0, GetMidiInputChannel());
135 capela 159 }
136 schoenebeck 203
137 capela 159 void SamplerChannel::SetMidiInputPort(int MidiPort) {
138 schoenebeck 675 SetMidiInput(GetMidiInputDevice(), MidiPort, GetMidiInputChannel());
139 capela 159 }
140 schoenebeck 203
141 schoenebeck 675 void SamplerChannel::SetMidiInputChannel(midi_chan_t MidiChannel) {
142     SetMidiInput(GetMidiInputDevice(), GetMidiInputPort(), MidiChannel);
143 capela 159 }
144 schoenebeck 203
145 schoenebeck 675 void SamplerChannel::SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, midi_chan_t MidiChannel) {
146 schoenebeck 880 if (!pDevice) throw Exception("No MIDI input device assigned.");
147 schoenebeck 675
148     // get old and new midi input port
149     MidiInputPort* pOldMidiInputPort = __GetMidiInputDevicePort(GetMidiInputPort());
150     MidiInputPort* pNewMidiInputPort = pDevice->GetPort(iMidiPort);
151    
152 capela 159 // disconnect old device port
153 schoenebeck 675 if (pOldMidiInputPort && pEngineChannel) pOldMidiInputPort->Disconnect(pEngineChannel);
154     // remember new device, port and channel if not engine channel yet created
155     if (!pEngineChannel) {
156     this->pMidiInputDevice = pDevice;
157     this->iMidiPort = iMidiPort;
158     this->midiChannel = MidiChannel;
159     }
160    
161 capela 159 // connect new device port
162 schoenebeck 675 if (pNewMidiInputPort && pEngineChannel) pNewMidiInputPort->Connect(pEngineChannel, MidiChannel);
163 capela 159 // Ooops.
164 schoenebeck 675 if (pNewMidiInputPort == NULL)
165 schoenebeck 880 throw Exception("There is no MIDI input port with index " + ToString(iMidiPort) + ".");
166 schoenebeck 53 }
167    
168 schoenebeck 411 EngineChannel* SamplerChannel::GetEngineChannel() {
169     return pEngineChannel;
170 schoenebeck 53 }
171    
172 schoenebeck 675 midi_chan_t SamplerChannel::GetMidiInputChannel() {
173     if (pEngineChannel) this->midiChannel = pEngineChannel->MidiChannel();
174 capela 159 return this->midiChannel;
175 schoenebeck 53 }
176    
177 capela 159 int SamplerChannel::GetMidiInputPort() {
178 schoenebeck 675 MidiInputPort* pMidiInputPort = (pEngineChannel) ? pEngineChannel->GetMidiInputPort() : NULL;
179     if (pMidiInputPort) this->iMidiPort = (int) pMidiInputPort->GetPortNumber();
180     return iMidiPort;
181 capela 159 }
182    
183 schoenebeck 53 AudioOutputDevice* SamplerChannel::GetAudioOutputDevice() {
184     return pAudioOutputDevice;
185     }
186    
187 senkov 155 MidiInputDevice* SamplerChannel::GetMidiInputDevice() {
188 schoenebeck 675 if (pEngineChannel)
189     pMidiInputDevice = (pEngineChannel->GetMidiInputPort()) ? pEngineChannel->GetMidiInputPort()->GetDevice() : NULL;
190 capela 159 return pMidiInputDevice;
191 senkov 155 }
192    
193 schoenebeck 53 uint SamplerChannel::Index() {
194     if (iIndex >= 0) return iIndex;
195    
196 schoenebeck 209 Sampler::SamplerChannelMap::iterator iter = pSampler->mSamplerChannels.begin();
197     for (; iter != pSampler->mSamplerChannels.end(); iter++) {
198     if (iter->second == this) {
199     iIndex = iter->first;
200     return iIndex;
201 schoenebeck 53 }
202     }
203    
204 schoenebeck 880 throw Exception("Internal error: SamplerChannel index not found");
205 schoenebeck 53 }
206    
207 iliev 1130 void SamplerChannel::AddEngineChangeListener(EngineChangeListener* l) {
208     llEngineChangeListeners.AddListener(l);
209     }
210    
211     void SamplerChannel::RemoveEngineChangeListener(EngineChangeListener* l) {
212     llEngineChangeListeners.RemoveListener(l);
213     }
214    
215     void SamplerChannel::RemoveAllEngineChangeListeners() {
216     llEngineChangeListeners.RemoveAllListeners();
217     }
218    
219     void SamplerChannel::fireEngineChanged() {
220     for (int i = 0; i < llEngineChangeListeners.GetListenerCount(); i++) {
221     llEngineChangeListeners.GetListener(i)->EngineChanged(Index());
222     }
223     }
224    
225 schoenebeck 675 MidiInputPort* SamplerChannel::__GetMidiInputDevicePort(int iMidiPort) {
226 schoenebeck 221 MidiInputPort* pMidiInputPort = NULL;
227 schoenebeck 675 MidiInputDevice* pMidiInputDevice = GetMidiInputDevice();
228 capela 159 if (pMidiInputDevice)
229 schoenebeck 221 pMidiInputPort = pMidiInputDevice->GetPort(iMidiPort);
230 capela 159 return pMidiInputPort;
231     }
232 schoenebeck 53
233 schoenebeck 212
234    
235 schoenebeck 53 // ******************************************************************
236     // * Sampler
237    
238     Sampler::Sampler() {
239 iliev 1130 eventHandler.SetSampler(this);
240 schoenebeck 53 }
241    
242     Sampler::~Sampler() {
243 schoenebeck 212 Reset();
244 schoenebeck 53 }
245    
246     uint Sampler::SamplerChannels() {
247 schoenebeck 209 return mSamplerChannels.size();
248 schoenebeck 53 }
249    
250 iliev 1130 void Sampler::AddChannelCountListener(ChannelCountListener* l) {
251     llChannelCountListeners.AddListener(l);
252     }
253    
254     void Sampler::RemoveChannelCountListener(ChannelCountListener* l) {
255     llChannelCountListeners.RemoveListener(l);
256     }
257    
258     void Sampler::fireChannelCountChanged(int NewCount) {
259     for (int i = 0; i < llChannelCountListeners.GetListenerCount(); i++) {
260     llChannelCountListeners.GetListener(i)->ChannelCountChanged(NewCount);
261     }
262     }
263    
264     void Sampler::AddAudioDeviceCountListener(AudioDeviceCountListener* l) {
265     llAudioDeviceCountListeners.AddListener(l);
266     }
267    
268     void Sampler::RemoveAudioDeviceCountListener(AudioDeviceCountListener* l) {
269     llAudioDeviceCountListeners.RemoveListener(l);
270     }
271    
272     void Sampler::fireAudioDeviceCountChanged(int NewCount) {
273     for (int i = 0; i < llAudioDeviceCountListeners.GetListenerCount(); i++) {
274     llAudioDeviceCountListeners.GetListener(i)->AudioDeviceCountChanged(NewCount);
275     }
276     }
277    
278     void Sampler::AddMidiDeviceCountListener(MidiDeviceCountListener* l) {
279     llMidiDeviceCountListeners.AddListener(l);
280     }
281    
282     void Sampler::RemoveMidiDeviceCountListener(MidiDeviceCountListener* l) {
283     llMidiDeviceCountListeners.RemoveListener(l);
284     }
285    
286     void Sampler::fireMidiDeviceCountChanged(int NewCount) {
287     for (int i = 0; i < llMidiDeviceCountListeners.GetListenerCount(); i++) {
288     llMidiDeviceCountListeners.GetListener(i)->MidiDeviceCountChanged(NewCount);
289     }
290     }
291    
292     void Sampler::AddVoiceCountListener(VoiceCountListener* l) {
293     llVoiceCountListeners.AddListener(l);
294     }
295    
296     void Sampler::RemoveVoiceCountListener(VoiceCountListener* l) {
297     llVoiceCountListeners.RemoveListener(l);
298     }
299    
300     void Sampler::fireVoiceCountChanged(int ChannelId, int NewCount) {
301     for (int i = 0; i < llVoiceCountListeners.GetListenerCount(); i++) {
302     llVoiceCountListeners.GetListener(i)->VoiceCountChanged(ChannelId, NewCount);
303     }
304     }
305    
306     void Sampler::AddStreamCountListener(StreamCountListener* l) {
307     llStreamCountListeners.AddListener(l);
308     }
309    
310     void Sampler::RemoveStreamCountListener(StreamCountListener* l) {
311     llStreamCountListeners.RemoveListener(l);
312     }
313    
314     void Sampler::fireStreamCountChanged(int ChannelId, int NewCount) {
315     for (int i = 0; i < llStreamCountListeners.GetListenerCount(); i++) {
316     llStreamCountListeners.GetListener(i)->StreamCountChanged(ChannelId, NewCount);
317     }
318     }
319    
320     void Sampler::AddBufferFillListener(BufferFillListener* l) {
321     llBufferFillListeners.AddListener(l);
322     }
323    
324     void Sampler::RemoveBufferFillListener(BufferFillListener* l) {
325     llBufferFillListeners.RemoveListener(l);
326     }
327    
328     void Sampler::fireBufferFillChanged(int ChannelId, String FillData) {
329     for (int i = 0; i < llBufferFillListeners.GetListenerCount(); i++) {
330     llBufferFillListeners.GetListener(i)->BufferFillChanged(ChannelId, FillData);
331     }
332     }
333    
334     void Sampler::AddTotalVoiceCountListener(TotalVoiceCountListener* l) {
335     llTotalVoiceCountListeners.AddListener(l);
336     }
337    
338     void Sampler::RemoveTotalVoiceCountListener(TotalVoiceCountListener* l) {
339     llTotalVoiceCountListeners.RemoveListener(l);
340     }
341    
342     void Sampler::fireTotalVoiceCountChanged(int NewCount) {
343     for (int i = 0; i < llTotalVoiceCountListeners.GetListenerCount(); i++) {
344     llTotalVoiceCountListeners.GetListener(i)->TotalVoiceCountChanged(NewCount);
345     }
346     }
347    
348     void Sampler::AddFxSendCountListener(FxSendCountListener* l) {
349     llFxSendCountListeners.AddListener(l);
350     }
351    
352     void Sampler::RemoveFxSendCountListener(FxSendCountListener* l) {
353     llFxSendCountListeners.RemoveListener(l);
354     }
355    
356     void Sampler::fireFxSendCountChanged(int ChannelId, int NewCount) {
357     for (int i = 0; i < llFxSendCountListeners.GetListenerCount(); i++) {
358     llFxSendCountListeners.GetListener(i)->FxSendCountChanged(ChannelId, NewCount);
359     }
360     }
361    
362     void Sampler::EventHandler::EngineChanged(int ChannelId) {
363     EngineChannel* engineChannel = pSampler->GetSamplerChannel(ChannelId)->GetEngineChannel();
364     if(engineChannel == NULL) return;
365     engineChannel->AddFxSendCountListener(this);
366     }
367    
368     void Sampler::EventHandler::FxSendCountChanged(int ChannelId, int NewCount) {
369     pSampler->fireFxSendCountChanged(ChannelId, NewCount);
370     }
371    
372    
373 schoenebeck 53 SamplerChannel* Sampler::AddSamplerChannel() {
374 schoenebeck 209 // if there's no sampler channel yet
375     if (!mSamplerChannels.size()) {
376     SamplerChannel* pChannel = new SamplerChannel(this);
377     mSamplerChannels[0] = pChannel;
378 iliev 1130 fireChannelCountChanged(1);
379     pChannel->AddEngineChangeListener(&eventHandler);
380 schoenebeck 209 return pChannel;
381     }
382    
383     // get the highest used sampler channel index
384     uint lastIndex = (--(mSamplerChannels.end()))->first;
385    
386     // check if we reached the index limit
387     if (lastIndex + 1 < lastIndex) {
388     // search for an unoccupied sampler channel index starting from 0
389     for (uint i = 0; i < lastIndex; i++) {
390     if (mSamplerChannels.find(i) != mSamplerChannels.end()) continue;
391     // we found an unused index, so insert the new channel there
392     SamplerChannel* pChannel = new SamplerChannel(this);
393     mSamplerChannels[i] = pChannel;
394 iliev 1130 fireChannelCountChanged(SamplerChannels());
395     pChannel->AddEngineChangeListener(&eventHandler);
396 schoenebeck 209 return pChannel;
397     }
398 schoenebeck 880 throw Exception("Internal error: could not find unoccupied sampler channel index.");
399 schoenebeck 209 }
400    
401     // we have not reached the index limit so we just add the channel past the highest index
402 schoenebeck 53 SamplerChannel* pChannel = new SamplerChannel(this);
403 schoenebeck 209 mSamplerChannels[lastIndex + 1] = pChannel;
404 iliev 1130 fireChannelCountChanged(SamplerChannels());
405     pChannel->AddEngineChangeListener(&eventHandler);
406 schoenebeck 53 return pChannel;
407     }
408    
409     SamplerChannel* Sampler::GetSamplerChannel(uint uiSamplerChannel) {
410 schoenebeck 209 return (mSamplerChannels.find(uiSamplerChannel) != mSamplerChannels.end()) ? mSamplerChannels[uiSamplerChannel] : NULL;
411 schoenebeck 53 }
412    
413 schoenebeck 209 std::map<uint, SamplerChannel*> Sampler::GetSamplerChannels() {
414     return mSamplerChannels;
415     }
416    
417 schoenebeck 53 void Sampler::RemoveSamplerChannel(SamplerChannel* pSamplerChannel) {
418 schoenebeck 209 SamplerChannelMap::iterator iterChan = mSamplerChannels.begin();
419     for (; iterChan != mSamplerChannels.end(); iterChan++) {
420     if (iterChan->second == pSamplerChannel) {
421 iliev 1130 pSamplerChannel->RemoveAllEngineChangeListeners();
422 schoenebeck 209 mSamplerChannels.erase(iterChan);
423 schoenebeck 53 delete pSamplerChannel;
424 iliev 1130 fireChannelCountChanged(SamplerChannels());
425 schoenebeck 53 return;
426     }
427     }
428     }
429    
430     void Sampler::RemoveSamplerChannel(uint uiSamplerChannel) {
431     SamplerChannel* pChannel = GetSamplerChannel(uiSamplerChannel);
432     if (!pChannel) return;
433     RemoveSamplerChannel(pChannel);
434     }
435    
436 schoenebeck 123 std::vector<String> Sampler::AvailableAudioOutputDrivers() {
437     return AudioOutputDeviceFactory::AvailableDrivers();
438     }
439 schoenebeck 53
440 schoenebeck 900 std::vector<String> Sampler::AvailableMidiInputDrivers() {
441     return MidiInputDeviceFactory::AvailableDrivers();
442     }
443    
444     std::vector<String> Sampler::AvailableEngineTypes() {
445     return EngineFactory::AvailableEngineTypes();
446     }
447    
448 schoenebeck 880 AudioOutputDevice* Sampler::CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (Exception) {
449 schoenebeck 53 // create new device
450 schoenebeck 123 AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);
451 schoenebeck 53
452 schoenebeck 64 // add new audio device to the audio device list
453 schoenebeck 123 for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
454     if (!mAudioOutputDevices[i]) {
455     mAudioOutputDevices[i] = pDevice;
456     break;
457     }
458     }
459 schoenebeck 64
460 iliev 1130 fireAudioDeviceCountChanged(AudioOutputDevices());
461 schoenebeck 53 return pDevice;
462     }
463    
464 schoenebeck 123 uint Sampler::AudioOutputDevices() {
465     return mAudioOutputDevices.size();
466 schoenebeck 53 }
467    
468 senkov 155 uint Sampler::MidiInputDevices() {
469     return mMidiInputDevices.size();
470     }
471    
472 schoenebeck 123 std::map<uint, AudioOutputDevice*> Sampler::GetAudioOutputDevices() {
473     return mAudioOutputDevices;
474     }
475    
476 senkov 155 std::map<uint, MidiInputDevice*> Sampler::GetMidiInputDevices() {
477     return mMidiInputDevices;
478     }
479    
480 schoenebeck 880 void Sampler::DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (Exception) {
481 schoenebeck 123 AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
482     for (; iter != mAudioOutputDevices.end(); iter++) {
483     if (iter->second == pDevice) {
484     // check if there are still sampler engines connected to this device
485     for (uint i = 0; i < SamplerChannels(); i++)
486 schoenebeck 880 if (GetSamplerChannel(i)->GetAudioOutputDevice() == pDevice) throw Exception("Sampler channel " + ToString(i) + " is still connected to the audio output device.");
487 schoenebeck 123
488     // disable device
489     pDevice->Stop();
490    
491 persson 837 // remove device from the device list
492     mAudioOutputDevices.erase(iter);
493    
494 schoenebeck 123 // destroy and free device from memory
495     delete pDevice;
496 persson 837
497 iliev 1130 fireAudioDeviceCountChanged(AudioOutputDevices());
498 persson 837 break;
499 schoenebeck 123 }
500     }
501     }
502    
503 schoenebeck 880 void Sampler::DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (Exception) {
504 senkov 155 MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
505     for (; iter != mMidiInputDevices.end(); iter++) {
506     if (iter->second == pDevice) {
507     // check if there are still sampler engines connected to this device
508     for (uint i = 0; i < SamplerChannels(); i++)
509 schoenebeck 880 if (GetSamplerChannel(i)->GetMidiInputDevice() == pDevice) throw Exception("Sampler channel " + ToString(i) + " is still connected to the midi input device.");
510 schoenebeck 53
511 senkov 155 // disable device
512     pDevice->StopListen();
513    
514 persson 837 // remove device from the device list
515     mMidiInputDevices.erase(iter);
516    
517 senkov 155 // destroy and free device from memory
518     delete pDevice;
519 persson 837
520 iliev 1130 fireMidiDeviceCountChanged(MidiInputDevices());
521 persson 837 break;
522 senkov 155 }
523 schoenebeck 53 }
524 senkov 155 }
525 schoenebeck 53
526 schoenebeck 880 MidiInputDevice* Sampler::CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (Exception) {
527 senkov 155 // create new device
528 schoenebeck 551 MidiInputDevice* pDevice = MidiInputDeviceFactory::Create(MidiDriver, Parameters, this);
529 senkov 155
530     // add new device to the midi device list
531     for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
532     if (!mMidiInputDevices[i]) {
533     mMidiInputDevices[i] = pDevice;
534     break;
535     }
536     }
537 schoenebeck 64
538 iliev 1130 fireMidiDeviceCountChanged(MidiInputDevices());
539 schoenebeck 53 return pDevice;
540     }
541    
542 iliev 778 int Sampler::GetVoiceCount() {
543     int count = 0;
544     std::set<Engine*>::iterator it = EngineFactory::EngineInstances().begin();
545    
546     for(; it != EngineFactory::EngineInstances().end(); it++) {
547     count += (*it)->VoiceCount();
548     }
549    
550     return count;
551     }
552    
553 schoenebeck 212 void Sampler::Reset() {
554     // delete sampler channels
555     try {
556 senkov 329 while (true) {
557     SamplerChannelMap::iterator iter = mSamplerChannels.begin();
558     if (iter == mSamplerChannels.end()) break;
559     RemoveSamplerChannel(iter->second);
560 schoenebeck 212 }
561     }
562     catch(...) {
563     std::cerr << "Sampler::Reset(): Exception occured while trying to delete all sampler channels, exiting.\n" << std::flush;
564     exit(EXIT_FAILURE);
565     }
566    
567     // delete midi input devices
568     try {
569 senkov 329 while (true) {
570     MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
571     if (iter == mMidiInputDevices.end()) break;
572     DestroyMidiInputDevice(iter->second);
573 schoenebeck 212 }
574     }
575     catch(...) {
576     std::cerr << "Sampler::Reset(): Exception occured while trying to delete all MIDI input devices, exiting.\n" << std::flush;
577     exit(EXIT_FAILURE);
578     }
579    
580     // delete audio output devices
581     try {
582 senkov 329 while (true) {
583     AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
584     if (iter == mAudioOutputDevices.end()) break;
585     DestroyAudioOutputDevice(iter->second);
586 schoenebeck 212 }
587     }
588     catch(...) {
589     std::cerr << "Sampler::Reset(): Exception occured while trying to delete all audio output devices, exiting.\n" << std::flush;
590     exit(EXIT_FAILURE);
591     }
592 schoenebeck 1008
593     // delete MIDI instrument maps
594     try {
595     MidiInstrumentMapper::RemoveAllMaps();
596     }
597     catch(...) {
598     std::cerr << "Sampler::Reset(): Exception occured while trying to delete all MIDI instrument maps, exiting.\n" << std::flush;
599     exit(EXIT_FAILURE);
600     }
601 schoenebeck 212 }
602    
603 schoenebeck 53 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC