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

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

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

revision 159 by capela, Tue Jun 29 21:11:50 2004 UTC revision 212 by schoenebeck, Wed Jul 28 14:17:29 2004 UTC
# Line 24  Line 24 
24    
25  #include "Sampler.h"  #include "Sampler.h"
26    
27  #include "audiodriver/AudioOutputDeviceFactory.h"  #include "drivers/audio/AudioOutputDeviceFactory.h"
28  #include "mididriver/MidiInputDeviceFactory.h"  #include "drivers/midi/MidiInputDeviceFactory.h"
29  #include "engines/gig/Engine.h"  #include "engines/gig/Engine.h"
30    
31  namespace LinuxSampler {  namespace LinuxSampler {
# Line 92  namespace LinuxSampler { Line 92  namespace LinuxSampler {
92      void SamplerChannel::SetMidiInputDevice(MidiInputDevice* pDevice) {      void SamplerChannel::SetMidiInputDevice(MidiInputDevice* pDevice) {
93         SetMidiInput(pDevice, this->midiPort, this->midiChannel);         SetMidiInput(pDevice, this->midiPort, this->midiChannel);
94      }      }
95        
96      void SamplerChannel::SetMidiInputPort(int MidiPort) {      void SamplerChannel::SetMidiInputPort(int MidiPort) {
97         SetMidiInput(pMidiInputDevice, MidiPort, this->midiChannel);         SetMidiInput(pMidiInputDevice, MidiPort, this->midiChannel);
98      }      }
99        
100      void SamplerChannel::SetMidiInputChannel(MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {      void SamplerChannel::SetMidiInputChannel(MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {
101         SetMidiInput(pMidiInputDevice, this->midiPort, MidiChannel);         SetMidiInput(pMidiInputDevice, this->midiPort, MidiChannel);
102      }      }
103        
104      void SamplerChannel::SetMidiInput(MidiInputDevice* pDevice, int MidiPort, MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {      void SamplerChannel::SetMidiInput(MidiInputDevice* pDevice, int MidiPort, MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {
105          // dereference old midi input port.          // dereference old midi input port.
106          MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);          MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
# Line 142  namespace LinuxSampler { Line 142  namespace LinuxSampler {
142      uint SamplerChannel::Index() {      uint SamplerChannel::Index() {
143          if (iIndex >= 0) return iIndex;          if (iIndex >= 0) return iIndex;
144    
145          std::vector<SamplerChannel*>::iterator iter = pSampler->vSamplerChannels.begin();          Sampler::SamplerChannelMap::iterator iter = pSampler->mSamplerChannels.begin();
146          for (int i = 0; iter != pSampler->vSamplerChannels.end(); i++, iter++) {          for (; iter != pSampler->mSamplerChannels.end(); iter++) {
147              if (*iter == this) {              if (iter->second == this) {
148                  iIndex = i;                  iIndex = iter->first;
149                  return i;                  return iIndex;
150              }              }
151          }          }
152    
153          throw LinuxSamplerException("SamplerChannel index not found");          throw LinuxSamplerException("Internal error: SamplerChannel index not found");
154      }      }
155    
156      MidiInputDevice::MidiInputPort* SamplerChannel::GetMidiInputDevicePort(int MidiPort) {      MidiInputDevice::MidiInputPort* SamplerChannel::GetMidiInputDevicePort(int MidiPort) {
# Line 160  namespace LinuxSampler { Line 160  namespace LinuxSampler {
160          return pMidiInputPort;          return pMidiInputPort;
161      }      }
162    
163    
164    
165      // ******************************************************************      // ******************************************************************
166      // * Sampler      // * Sampler
167    
# Line 167  namespace LinuxSampler { Line 169  namespace LinuxSampler {
169      }      }
170    
171      Sampler::~Sampler() {      Sampler::~Sampler() {
172          // delete sampler channels          Reset();
         {  
             std::vector<SamplerChannel*>::iterator iter = vSamplerChannels.begin();  
             for (; iter != vSamplerChannels.end(); iter++) delete *iter;  
         }  
   
         // delete midi input devices  
         {  
             MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();  
             for (; iter != mMidiInputDevices.end(); iter++) {  
                 MidiInputDevice* pDevice = iter->second;  
                 pDevice->StopListen();  
                 delete pDevice;  
             }  
         }  
   
         // delete audio output devices  
         {  
             AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();  
             for (; iter != mAudioOutputDevices.end(); iter++) {  
                 AudioOutputDevice* pDevice = iter->second;  
                 pDevice->Stop();  
                 delete pDevice;  
             }  
         }  
173      }      }
174    
175      uint Sampler::SamplerChannels() {      uint Sampler::SamplerChannels() {
176          return vSamplerChannels.size();          return mSamplerChannels.size();
177      }      }
178    
179      SamplerChannel* Sampler::AddSamplerChannel() {      SamplerChannel* Sampler::AddSamplerChannel() {
180            // if there's no sampler channel yet
181            if (!mSamplerChannels.size()) {
182                SamplerChannel* pChannel = new SamplerChannel(this);
183                mSamplerChannels[0] = pChannel;
184                return pChannel;
185            }
186    
187            // get the highest used sampler channel index
188            uint lastIndex = (--(mSamplerChannels.end()))->first;
189    
190            // check if we reached the index limit
191            if (lastIndex + 1 < lastIndex) {
192                // search for an unoccupied sampler channel index starting from 0
193                for (uint i = 0; i < lastIndex; i++) {
194                    if (mSamplerChannels.find(i) != mSamplerChannels.end()) continue;
195                    // we found an unused index, so insert the new channel there
196                    SamplerChannel* pChannel = new SamplerChannel(this);
197                    mSamplerChannels[i] = pChannel;
198                    return pChannel;
199                }
200                throw LinuxSamplerException("Internal error: could not find unoccupied sampler channel index.");
201            }
202    
203            // we have not reached the index limit so we just add the channel past the highest index
204          SamplerChannel* pChannel = new SamplerChannel(this);          SamplerChannel* pChannel = new SamplerChannel(this);
205          vSamplerChannels.push_back(pChannel);          mSamplerChannels[lastIndex + 1] = pChannel;
206          return pChannel;          return pChannel;
207      }      }
208    
209      SamplerChannel* Sampler::GetSamplerChannel(uint uiSamplerChannel) {      SamplerChannel* Sampler::GetSamplerChannel(uint uiSamplerChannel) {
210          if (uiSamplerChannel >= SamplerChannels()) return NULL;          return (mSamplerChannels.find(uiSamplerChannel) != mSamplerChannels.end()) ? mSamplerChannels[uiSamplerChannel] : NULL;
211          return vSamplerChannels[uiSamplerChannel];      }
212    
213        std::map<uint, SamplerChannel*> Sampler::GetSamplerChannels() {
214            return mSamplerChannels;
215      }      }
216    
217      void Sampler::RemoveSamplerChannel(SamplerChannel* pSamplerChannel) {      void Sampler::RemoveSamplerChannel(SamplerChannel* pSamplerChannel) {
218          std::vector<SamplerChannel*>::iterator iterChan = vSamplerChannels.begin();          SamplerChannelMap::iterator iterChan = mSamplerChannels.begin();
219          for (; iterChan != vSamplerChannels.end(); iterChan++) {          for (; iterChan != mSamplerChannels.end(); iterChan++) {
220              if (*iterChan == pSamplerChannel) {              if (iterChan->second == pSamplerChannel) {
221                  vSamplerChannels.erase(iterChan);                  mSamplerChannels.erase(iterChan);
222                  delete pSamplerChannel;                  delete pSamplerChannel;
223                  return;                  return;
224              }              }
# Line 234  namespace LinuxSampler { Line 239  namespace LinuxSampler {
239          // create new device          // create new device
240          AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);          AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);
241    
         // activate device  
         pDevice->Play();  
   
242          // add new audio device to the audio device list          // add new audio device to the audio device list
243          for (uint i = 0; ; i++) { // seek for a free place starting from the beginning          for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
244              if (!mAudioOutputDevices[i]) {              if (!mAudioOutputDevices[i]) {
# Line 308  namespace LinuxSampler { Line 310  namespace LinuxSampler {
310          // create new device          // create new device
311          MidiInputDevice* pDevice = MidiInputDeviceFactory::Create(MidiDriver, Parameters);          MidiInputDevice* pDevice = MidiInputDeviceFactory::Create(MidiDriver, Parameters);
312    
         // activate device  
         pDevice->Listen();  
   
313          // add new device to the midi device list          // add new device to the midi device list
314          for (uint i = 0; ; i++) { // seek for a free place starting from the beginning          for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
315                  if (!mMidiInputDevices[i]) {                  if (!mMidiInputDevices[i]) {
# Line 322  namespace LinuxSampler { Line 321  namespace LinuxSampler {
321          return pDevice;          return pDevice;
322      }      }
323    
324        void Sampler::Reset() {
325            // delete sampler channels
326            try {
327                SamplerChannelMap::iterator iter = mSamplerChannels.begin();
328                for (; iter != mSamplerChannels.end(); iter++) {
329                    RemoveSamplerChannel(iter->second);
330                }
331            }
332            catch(...) {
333                std::cerr << "Sampler::Reset(): Exception occured while trying to delete all sampler channels, exiting.\n" << std::flush;
334                exit(EXIT_FAILURE);
335            }
336    
337            // delete midi input devices
338            try {
339                MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
340                for (; iter != mMidiInputDevices.end(); iter++) {
341                    DestroyMidiInputDevice(iter->second);
342                }
343            }
344            catch(...) {
345                std::cerr << "Sampler::Reset(): Exception occured while trying to delete all MIDI input devices, exiting.\n" << std::flush;
346                exit(EXIT_FAILURE);
347            }
348    
349            // delete audio output devices
350            try {
351                AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
352                for (; iter != mAudioOutputDevices.end(); iter++) {
353                    DestroyAudioOutputDevice(iter->second);
354                }
355            }
356            catch(...) {
357                std::cerr << "Sampler::Reset(): Exception occured while trying to delete all audio output devices, exiting.\n" << std::flush;
358                exit(EXIT_FAILURE);
359            }
360        }
361    
362  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.159  
changed lines
  Added in v.212
  ViewVC Help
Powered by ViewVC