/[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 1212 by schoenebeck, Tue May 29 23:59:36 2007 UTC revision 1765 by persson, Sat Sep 6 16:44:42 2008 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 - 2007 Christian Schoenebeck                       *   *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library 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 25  Line 25 
25    
26  #include "Sampler.h"  #include "Sampler.h"
27    
28    #include "common/global_private.h"
29  #include "engines/EngineFactory.h"  #include "engines/EngineFactory.h"
30  #include "engines/EngineChannelFactory.h"  #include "engines/EngineChannelFactory.h"
31  #include "engines/InstrumentEditorFactory.h"  #include "plugins/InstrumentEditorFactory.h"
32  #include "drivers/audio/AudioOutputDeviceFactory.h"  #include "drivers/audio/AudioOutputDeviceFactory.h"
33  #include "drivers/midi/MidiInputDeviceFactory.h"  #include "drivers/midi/MidiInputDeviceFactory.h"
34  #include "drivers/midi/MidiInstrumentMapper.h"  #include "drivers/midi/MidiInstrumentMapper.h"
35    #include "common/Features.h"
36    #include "network/lscpserver.h"
37    
38  namespace LinuxSampler {  namespace LinuxSampler {
39    
# Line 67  namespace LinuxSampler { Line 70  namespace LinuxSampler {
70    
71      void SamplerChannel::SetEngineType(String EngineType) throw (Exception) {      void SamplerChannel::SetEngineType(String EngineType) throw (Exception) {
72          dmsg(2,("SamplerChannel: Assigning engine type..."));          dmsg(2,("SamplerChannel: Assigning engine type..."));
73            
74            if (pEngineChannel) {
75                if (!strcasecmp(pEngineChannel->EngineName().c_str(), EngineType.c_str())) {
76                    dmsg(2,("OK\n"));
77                    return;
78                }
79            }
80    
81            fireEngineToBeChanged();
82    
83          // create new engine channel          // create new engine channel
84          EngineChannel* pNewEngineChannel = EngineChannelFactory::Create(EngineType);          EngineChannel* pNewEngineChannel = EngineChannelFactory::Create(EngineType);
85          if (!pNewEngineChannel) throw Exception("Unknown engine type");          if (!pNewEngineChannel) throw Exception("Unknown engine type");
86    
87          //FIXME: hack to allow fast retrieval of engine channel's sampler channel index          pNewEngineChannel->SetSamplerChannel(this);
         pNewEngineChannel->iSamplerChannelIndex = Index();  
88    
89          // dereference midi input port.          // dereference midi input port.
90          MidiInputPort* pMidiInputPort = __GetMidiInputDevicePort(GetMidiInputPort());          MidiInputPort* pMidiInputPort = __GetMidiInputDevicePort(GetMidiInputPort());
# Line 205  namespace LinuxSampler { Line 216  namespace LinuxSampler {
216          throw Exception("Internal error: SamplerChannel index not found");          throw Exception("Internal error: SamplerChannel index not found");
217      }      }
218    
219        Sampler* SamplerChannel::GetSampler() {
220            return pSampler;
221        }
222    
223      void SamplerChannel::AddEngineChangeListener(EngineChangeListener* l) {      void SamplerChannel::AddEngineChangeListener(EngineChangeListener* l) {
224          llEngineChangeListeners.AddListener(l);          llEngineChangeListeners.AddListener(l);
225      }      }
# Line 217  namespace LinuxSampler { Line 232  namespace LinuxSampler {
232         llEngineChangeListeners.RemoveAllListeners();         llEngineChangeListeners.RemoveAllListeners();
233      }      }
234    
235        void SamplerChannel::fireEngineToBeChanged() {
236            for (int i = 0; i < llEngineChangeListeners.GetListenerCount(); i++) {
237                llEngineChangeListeners.GetListener(i)->EngineToBeChanged(Index());
238            }
239        }
240    
241      void SamplerChannel::fireEngineChanged() {      void SamplerChannel::fireEngineChanged() {
242          for (int i = 0; i < llEngineChangeListeners.GetListenerCount(); i++) {          for (int i = 0; i < llEngineChangeListeners.GetListenerCount(); i++) {
243              llEngineChangeListeners.GetListener(i)->EngineChanged(Index());              llEngineChangeListeners.GetListener(i)->EngineChanged(Index());
# Line 262  namespace LinuxSampler { Line 283  namespace LinuxSampler {
283          }          }
284      }      }
285    
286        void Sampler::fireChannelAdded(SamplerChannel* pChannel) {
287            for (int i = 0; i < llChannelCountListeners.GetListenerCount(); i++) {
288                llChannelCountListeners.GetListener(i)->ChannelAdded(pChannel);
289            }
290        }
291    
292        void Sampler::fireChannelToBeRemoved(SamplerChannel* pChannel) {
293            for (int i = 0; i < llChannelCountListeners.GetListenerCount(); i++) {
294                llChannelCountListeners.GetListener(i)->ChannelToBeRemoved(pChannel);
295            }
296        }
297    
298      void Sampler::AddAudioDeviceCountListener(AudioDeviceCountListener* l) {      void Sampler::AddAudioDeviceCountListener(AudioDeviceCountListener* l) {
299          llAudioDeviceCountListeners.AddListener(l);          llAudioDeviceCountListeners.AddListener(l);
300      }      }
# Line 290  namespace LinuxSampler { Line 323  namespace LinuxSampler {
323          }          }
324      }      }
325    
326        void Sampler::fireMidiDeviceToBeDestroyed(MidiInputDevice* pDevice) {
327            for (int i = 0; i < llMidiDeviceCountListeners.GetListenerCount(); i++) {
328                llMidiDeviceCountListeners.GetListener(i)->MidiDeviceToBeDestroyed(pDevice);
329            }
330        }
331    
332        void Sampler::fireMidiDeviceCreated(MidiInputDevice* pDevice) {
333            for (int i = 0; i < llMidiDeviceCountListeners.GetListenerCount(); i++) {
334                llMidiDeviceCountListeners.GetListener(i)->MidiDeviceCreated(pDevice);
335            }
336        }
337    
338      void Sampler::AddVoiceCountListener(VoiceCountListener* l) {      void Sampler::AddVoiceCountListener(VoiceCountListener* l) {
339          llVoiceCountListeners.AddListener(l);          llVoiceCountListeners.AddListener(l);
340      }      }
# Line 332  namespace LinuxSampler { Line 377  namespace LinuxSampler {
377          }          }
378      }      }
379    
380        void Sampler::AddTotalStreamCountListener(TotalStreamCountListener* l) {
381            llTotalStreamCountListeners.AddListener(l);
382        }
383    
384        void Sampler::RemoveTotalStreamCountListener(TotalStreamCountListener* l) {
385            llTotalStreamCountListeners.RemoveListener(l);
386        }
387    
388        void Sampler::fireTotalStreamCountChanged(int NewCount) {
389            for (int i = 0; i < llTotalStreamCountListeners.GetListenerCount(); i++) {
390                llTotalStreamCountListeners.GetListener(i)->TotalStreamCountChanged(NewCount);
391            }
392        }
393    
394      void Sampler::AddTotalVoiceCountListener(TotalVoiceCountListener* l) {      void Sampler::AddTotalVoiceCountListener(TotalVoiceCountListener* l) {
395          llTotalVoiceCountListeners.AddListener(l);          llTotalVoiceCountListeners.AddListener(l);
396      }      }
# Line 360  namespace LinuxSampler { Line 419  namespace LinuxSampler {
419          }          }
420      }      }
421    
422        void Sampler::EventHandler::EngineToBeChanged(int ChannelId) {
423            // nothing to do here
424        }
425    
426      void Sampler::EventHandler::EngineChanged(int ChannelId) {      void Sampler::EventHandler::EngineChanged(int ChannelId) {
427          EngineChannel* engineChannel = pSampler->GetSamplerChannel(ChannelId)->GetEngineChannel();          EngineChannel* engineChannel = pSampler->GetSamplerChannel(ChannelId)->GetEngineChannel();
428          if(engineChannel == NULL) return;          if(engineChannel == NULL) return;
# Line 376  namespace LinuxSampler { Line 439  namespace LinuxSampler {
439          if (!mSamplerChannels.size()) {          if (!mSamplerChannels.size()) {
440              SamplerChannel* pChannel = new SamplerChannel(this);              SamplerChannel* pChannel = new SamplerChannel(this);
441              mSamplerChannels[0] = pChannel;              mSamplerChannels[0] = pChannel;
442                fireChannelAdded(pChannel);
443              fireChannelCountChanged(1);              fireChannelCountChanged(1);
444              pChannel->AddEngineChangeListener(&eventHandler);              pChannel->AddEngineChangeListener(&eventHandler);
445              return pChannel;              return pChannel;
# Line 392  namespace LinuxSampler { Line 456  namespace LinuxSampler {
456                  // we found an unused index, so insert the new channel there                  // we found an unused index, so insert the new channel there
457                  SamplerChannel* pChannel = new SamplerChannel(this);                  SamplerChannel* pChannel = new SamplerChannel(this);
458                  mSamplerChannels[i] = pChannel;                  mSamplerChannels[i] = pChannel;
459                    fireChannelAdded(pChannel);
460                  fireChannelCountChanged(SamplerChannels());                  fireChannelCountChanged(SamplerChannels());
461                  pChannel->AddEngineChangeListener(&eventHandler);                  pChannel->AddEngineChangeListener(&eventHandler);
462                  return pChannel;                  return pChannel;
# Line 402  namespace LinuxSampler { Line 467  namespace LinuxSampler {
467          // we have not reached the index limit so we just add the channel past the highest index          // we have not reached the index limit so we just add the channel past the highest index
468          SamplerChannel* pChannel = new SamplerChannel(this);          SamplerChannel* pChannel = new SamplerChannel(this);
469          mSamplerChannels[lastIndex + 1] = pChannel;          mSamplerChannels[lastIndex + 1] = pChannel;
470            fireChannelAdded(pChannel);
471          fireChannelCountChanged(SamplerChannels());          fireChannelCountChanged(SamplerChannels());
472          pChannel->AddEngineChangeListener(&eventHandler);          pChannel->AddEngineChangeListener(&eventHandler);
473          return pChannel;          return pChannel;
# Line 419  namespace LinuxSampler { Line 485  namespace LinuxSampler {
485          SamplerChannelMap::iterator iterChan = mSamplerChannels.begin();          SamplerChannelMap::iterator iterChan = mSamplerChannels.begin();
486          for (; iterChan != mSamplerChannels.end(); iterChan++) {          for (; iterChan != mSamplerChannels.end(); iterChan++) {
487              if (iterChan->second == pSamplerChannel) {              if (iterChan->second == pSamplerChannel) {
488                    fireChannelToBeRemoved(pSamplerChannel);
489                  pSamplerChannel->RemoveAllEngineChangeListeners();                  pSamplerChannel->RemoveAllEngineChangeListeners();
490                  mSamplerChannels.erase(iterChan);                  mSamplerChannels.erase(iterChan);
491                  delete pSamplerChannel;                  delete pSamplerChannel;
# Line 509  namespace LinuxSampler { Line 576  namespace LinuxSampler {
576                  for (uint i = 0; i < SamplerChannels(); i++)                  for (uint i = 0; i < SamplerChannels(); i++)
577                      if (GetSamplerChannel(i)->GetMidiInputDevice() == pDevice) throw Exception("Sampler channel " + ToString(i) + " is still connected to the midi input device.");                      if (GetSamplerChannel(i)->GetMidiInputDevice() == pDevice) throw Exception("Sampler channel " + ToString(i) + " is still connected to the midi input device.");
578    
579                    fireMidiDeviceToBeDestroyed(pDevice);
580    
581                  // disable device                  // disable device
582                  pDevice->StopListen();                  pDevice->StopListen();
583    
# Line 536  namespace LinuxSampler { Line 605  namespace LinuxSampler {
605                  }                  }
606          }          }
607    
608            fireMidiDeviceCreated(pDevice);
609          fireMidiDeviceCountChanged(MidiInputDevices());          fireMidiDeviceCountChanged(MidiInputDevices());
610          return pDevice;          return pDevice;
611      }      }
612    
613        int Sampler::GetDiskStreamCount() {
614            int count = 0;
615            std::set<Engine*>::iterator it = EngineFactory::EngineInstances().begin();
616    
617            for(; it != EngineFactory::EngineInstances().end(); it++) {
618                count += (*it)->DiskStreamCount();
619            }
620    
621            return count;
622        }
623    
624      int Sampler::GetVoiceCount() {      int Sampler::GetVoiceCount() {
625          int count = 0;          int count = 0;
626          std::set<Engine*>::iterator it = EngineFactory::EngineInstances().begin();          std::set<Engine*>::iterator it = EngineFactory::EngineInstances().begin();
# Line 604  namespace LinuxSampler { Line 685  namespace LinuxSampler {
685          InstrumentEditorFactory::ClosePlugins();          InstrumentEditorFactory::ClosePlugins();
686      }      }
687    
688        bool Sampler::EnableDenormalsAreZeroMode() {
689            Features::detect();
690            return Features::enableDenormalsAreZeroMode();
691        }
692    
693        void Sampler::fireStatistics() {
694            static const LSCPEvent::event_t eventsArr[] = {
695                LSCPEvent::event_voice_count, LSCPEvent::event_stream_count,
696                LSCPEvent::event_buffer_fill, LSCPEvent::event_total_voice_count
697            };
698            static const std::list<LSCPEvent::event_t> events(eventsArr, eventsArr + 4);
699    
700            if (LSCPServer::EventSubscribers(events))
701            {
702                LSCPServer::LockRTNotify();
703                std::map<uint,SamplerChannel*> channels = GetSamplerChannels();
704                std::map<uint,SamplerChannel*>::iterator iter = channels.begin();
705                for (; iter != channels.end(); iter++) {
706                    SamplerChannel* pSamplerChannel = iter->second;
707                    EngineChannel* pEngineChannel = pSamplerChannel->GetEngineChannel();
708                    if (!pEngineChannel) continue;
709                    Engine* pEngine = pEngineChannel->GetEngine();
710                    if (!pEngine) continue;
711                    fireVoiceCountChanged(iter->first, pEngineChannel->GetVoiceCount());
712                    fireStreamCountChanged(iter->first, pEngineChannel->GetDiskStreamCount());
713                    fireBufferFillChanged(iter->first, pEngine->DiskStreamBufferFillPercentage());
714                    fireTotalStreamCountChanged(GetDiskStreamCount());
715                    fireTotalVoiceCountChanged(GetVoiceCount());
716                }
717                LSCPServer::UnlockRTNotify();
718            }
719        }
720    
721  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.1212  
changed lines
  Added in v.1765
  ViewVC Help
Powered by ViewVC