/[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 123 by schoenebeck, Mon Jun 14 19:33:16 2004 UTC revision 203 by schoenebeck, Tue Jul 13 22:44:13 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/MidiInputDeviceAlsa.h"  #include "drivers/midi/MidiInputDeviceFactory.h"
29  #include "engines/gig/Engine.h"  #include "engines/gig/Engine.h"
30    
31  namespace LinuxSampler {  namespace LinuxSampler {
# Line 38  namespace LinuxSampler { Line 38  namespace LinuxSampler {
38          pEngine            = NULL;          pEngine            = NULL;
39          pMidiInputDevice   = NULL;          pMidiInputDevice   = NULL;
40          pAudioOutputDevice = NULL;          pAudioOutputDevice = NULL;
41            midiPort           = 0;
42            midiChannel        = MidiInputDevice::MidiInputPort::midi_chan_all;
43          iIndex             = -1;          iIndex             = -1;
44      }      }
45    
46      SamplerChannel::~SamplerChannel() {      SamplerChannel::~SamplerChannel() {
47          if (pEngine) {          if (pEngine) {
48              if (pMidiInputDevice) pMidiInputDevice->Disconnect(pEngine);              MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
49                if (pMidiInputPort) pMidiInputPort->Disconnect(pEngine);
50              if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(pEngine);              if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(pEngine);
51              delete pEngine;              delete pEngine;
52          }          }
# Line 62  namespace LinuxSampler { Line 65  namespace LinuxSampler {
65                  throw LinuxSamplerException("Unknown engine type");                  throw LinuxSamplerException("Unknown engine type");
66          }          }
67    
68            // dereference midi input port.
69            MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
70          // disconnect old engine          // disconnect old engine
71          if (pEngine) {          if (pEngine) {
72              if (pMidiInputDevice) pMidiInputDevice->Disconnect(pEngine);              if (pMidiInputPort) pMidiInputPort->Disconnect(pEngine);
73              if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(pEngine);              if (pAudioOutputDevice) pAudioOutputDevice->Disconnect(pEngine);
74              delete pEngine;              delete pEngine;
75          }          }
76    
77          // connect new engine          // connect new engine
78          pEngine = pNewEngine;          pEngine = pNewEngine;
79          if (pMidiInputDevice) pMidiInputDevice->Connect(pNewEngine, (MidiInputDevice::midi_chan_t) Index());          if (pMidiInputPort) pMidiInputPort->Connect(pNewEngine, this->midiChannel);
80          if (pAudioOutputDevice) pAudioOutputDevice->Connect(pNewEngine);          if (pAudioOutputDevice) pAudioOutputDevice->Connect(pNewEngine);
81          dmsg(2,("OK\n"));          dmsg(2,("OK\n"));
82      }      }
# Line 79  namespace LinuxSampler { Line 84  namespace LinuxSampler {
84      void SamplerChannel::SetAudioOutputDevice(AudioOutputDevice* pDevice) {      void SamplerChannel::SetAudioOutputDevice(AudioOutputDevice* pDevice) {
85          // disconnect old device          // disconnect old device
86          if (pAudioOutputDevice && pEngine) pAudioOutputDevice->Disconnect(pEngine);          if (pAudioOutputDevice && pEngine) pAudioOutputDevice->Disconnect(pEngine);
   
87          // connect new device          // connect new device
88          pAudioOutputDevice = pDevice;          pAudioOutputDevice = pDevice;
89          if (pEngine) pAudioOutputDevice->Connect(pEngine);          if (pEngine) pAudioOutputDevice->Connect(pEngine);
90      }      }
91    
92      void SamplerChannel::SetMidiInputDevice(MidiInputDevice::type_t MidiType, MidiInputDevice::midi_chan_t MidiChannel) {      void SamplerChannel::SetMidiInputDevice(MidiInputDevice* pDevice) {
93          // get / create desired midi device         SetMidiInput(pDevice, this->midiPort, this->midiChannel);
94          MidiInputDevice* pDevice = pSampler->GetMidiInputDevice(MidiType);      }
         if (!pDevice) pDevice = pSampler->CreateMidiInputDevice(MidiType);  
95    
96          // disconnect old device      void SamplerChannel::SetMidiInputPort(int MidiPort) {
97          if (pMidiInputDevice && pEngine) pMidiInputDevice->Disconnect(pEngine);         SetMidiInput(pMidiInputDevice, MidiPort, this->midiChannel);
98        }
99    
100          // connect new device      void SamplerChannel::SetMidiInputChannel(MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {
101           SetMidiInput(pMidiInputDevice, this->midiPort, MidiChannel);
102        }
103    
104        void SamplerChannel::SetMidiInput(MidiInputDevice* pDevice, int MidiPort, MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel) {
105            // dereference old midi input port.
106            MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
107            // disconnect old device port
108            if (pMidiInputPort && pEngine) pMidiInputPort->Disconnect(pEngine);
109            // new device, port and channel
110          pMidiInputDevice = pDevice;          pMidiInputDevice = pDevice;
111          if (pEngine) pMidiInputDevice->Connect(pEngine, MidiChannel);          this->midiPort = MidiPort;
112            this->midiChannel = MidiChannel;
113            // connect new device port
114            pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
115            if (pMidiInputPort && pEngine) pMidiInputPort->Connect(pEngine, MidiChannel);
116            // Ooops.
117            if (pMidiInputPort == NULL)
118                throw LinuxSamplerException("There is no MIDI input port with index " + ToString(MidiPort) + ".");
119      }      }
120    
121      Engine* SamplerChannel::GetEngine() {      Engine* SamplerChannel::GetEngine() {
122          return pEngine;          return pEngine;
123      }      }
124    
125      MidiInputDevice* SamplerChannel::GetMidiInputDevice() {      MidiInputDevice::MidiInputPort::midi_chan_t SamplerChannel::GetMidiInputChannel() {
126          return pMidiInputDevice;          return this->midiChannel;
127        }
128    
129        int SamplerChannel::GetMidiInputPort() {
130            MidiInputDevice::MidiInputPort *pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
131            return (pMidiInputPort ? (int) pMidiInputPort->GetPortNumber() : -1);
132      }      }
133    
134      AudioOutputDevice* SamplerChannel::GetAudioOutputDevice() {      AudioOutputDevice* SamplerChannel::GetAudioOutputDevice() {
135          return pAudioOutputDevice;          return pAudioOutputDevice;
136      }      }
137    
138        MidiInputDevice* SamplerChannel::GetMidiInputDevice() {
139            return pMidiInputDevice;
140        }
141    
142      uint SamplerChannel::Index() {      uint SamplerChannel::Index() {
143          if (iIndex >= 0) return iIndex;          if (iIndex >= 0) return iIndex;
144    
# Line 124  namespace LinuxSampler { Line 153  namespace LinuxSampler {
153          throw LinuxSamplerException("SamplerChannel index not found");          throw LinuxSamplerException("SamplerChannel index not found");
154      }      }
155    
156        MidiInputDevice::MidiInputPort* SamplerChannel::GetMidiInputDevicePort(int MidiPort) {
157            MidiInputDevice::MidiInputPort *pMidiInputPort = NULL;
158            if (pMidiInputDevice)
159                pMidiInputPort = pMidiInputDevice->GetPort(MidiPort);
160            return pMidiInputPort;
161        }
162    
163      // ******************************************************************      // ******************************************************************
164      // * Sampler      // * Sampler
# Line 140  namespace LinuxSampler { Line 175  namespace LinuxSampler {
175    
176          // delete midi input devices          // delete midi input devices
177          {          {
178              MidiInputDeviceMap::iterator iter = MidiInputDevices.begin();              MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
179              for (; iter != MidiInputDevices.end(); iter++) {              for (; iter != mMidiInputDevices.end(); iter++) {
180                  MidiInputDevice* pDevice = iter->second;                  MidiInputDevice* pDevice = iter->second;
181                  pDevice->StopListen();                  pDevice->StopListen();
182                  delete pDevice;                  delete pDevice;
# Line 199  namespace LinuxSampler { Line 234  namespace LinuxSampler {
234          // create new device          // create new device
235          AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);          AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);
236    
         // activate device  
         pDevice->Play();  
   
237          // add new audio device to the audio device list          // add new audio device to the audio device list
238          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
239              if (!mAudioOutputDevices[i]) {              if (!mAudioOutputDevices[i]) {
# Line 217  namespace LinuxSampler { Line 249  namespace LinuxSampler {
249          return mAudioOutputDevices.size();          return mAudioOutputDevices.size();
250      }      }
251    
252        uint Sampler::MidiInputDevices() {
253            return mMidiInputDevices.size();
254        }
255    
256      std::map<uint, AudioOutputDevice*> Sampler::GetAudioOutputDevices() {      std::map<uint, AudioOutputDevice*> Sampler::GetAudioOutputDevices() {
257          return mAudioOutputDevices;          return mAudioOutputDevices;
258      }      }
259    
260        std::map<uint, MidiInputDevice*> Sampler::GetMidiInputDevices() {
261            return mMidiInputDevices;
262        }
263    
264      void Sampler::DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException) {      void Sampler::DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException) {
265          AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();          AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
266          for (; iter != mAudioOutputDevices.end(); iter++) {          for (; iter != mAudioOutputDevices.end(); iter++) {
# Line 241  namespace LinuxSampler { Line 281  namespace LinuxSampler {
281          }          }
282      }      }
283    
284      MidiInputDevice* Sampler::CreateMidiInputDevice(MidiInputDevice::type_t MidiType) {      void Sampler::DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException) {
285          // check if device already created          MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
286          MidiInputDevice* pDevice = GetMidiInputDevice(MidiType);          for (; iter != mMidiInputDevices.end(); iter++) {
287          if (pDevice) return pDevice;              if (iter->second == pDevice) {
288                    // check if there are still sampler engines connected to this device
289                    for (uint i = 0; i < SamplerChannels(); i++)
290                        if (GetSamplerChannel(i)->GetMidiInputDevice() == pDevice) throw LinuxSamplerException("Sampler channel " + ToString(i) + " is still connected to the midi input device.");
291    
292          // create new device                  // disable device
293          switch (MidiType) {                  pDevice->StopListen();
294              case MidiInputDevice::type_alsa:  
295                  pDevice = new MidiInputDeviceAlsa;                  // remove device from the device list
296                  break;                  mMidiInputDevices.erase(iter);
297              default:  
298                  throw LinuxSamplerException("Unknown audio output device type");                  // destroy and free device from memory
299                    delete pDevice;
300                }
301          }          }
302        }
303    
304          // activate device      MidiInputDevice* Sampler::CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException) {
305          pDevice->Listen();          // create new device
306            MidiInputDevice* pDevice = MidiInputDeviceFactory::Create(MidiDriver, Parameters);
307    
308          // add new MIDI device to the MIDI device list          // add new device to the midi device list
309          MidiInputDevices[MidiType] = pDevice;          for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
310                    if (!mMidiInputDevices[i]) {
311                            mMidiInputDevices[i] = pDevice;
312                            break;
313                    }
314            }
315    
316          return pDevice;          return pDevice;
317      }      }
318    
     MidiInputDevice* Sampler::GetMidiInputDevice(MidiInputDevice::type_t MidiType) {  
         MidiInputDeviceMap::iterator iter = MidiInputDevices.find(MidiType);  
         return (iter != MidiInputDevices.end()) ? iter->second : NULL;  
     }  
   
319  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.123  
changed lines
  Added in v.203
  ViewVC Help
Powered by ViewVC