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

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

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

revision 155 by senkov, Mon Jun 28 04:30:11 2004 UTC revision 212 by schoenebeck, Wed Jul 28 14:17:29 2004 UTC
# Line 28  Line 28 
28  #include "common/global.h"  #include "common/global.h"
29  #include "common/LinuxSamplerException.h"  #include "common/LinuxSamplerException.h"
30  #include "engines/common/Engine.h"  #include "engines/common/Engine.h"
31  #include "mididriver/MidiInputDevice.h"  #include "drivers/midi/MidiInputDevice.h"
32  #include "audiodriver/AudioOutputDevice.h"  #include "drivers/audio/AudioOutputDevice.h"
33    
34  namespace LinuxSampler {  namespace LinuxSampler {
35    
# Line 67  namespace LinuxSampler { Line 67  namespace LinuxSampler {
67              void SetAudioOutputDevice(AudioOutputDevice* pDevice);              void SetAudioOutputDevice(AudioOutputDevice* pDevice);
68    
69              /**              /**
70               * Connect this sampler channel to and MIDI input port               * Connect this sampler channel to and MIDI input device.
71               *               *
72               * @param MidiInputDevice - MIDI input device to connect to               * @param pDevice - MIDI input device to connect to
73               * @param MidiInputPort - MIDI port to connect to               */
74                void SetMidiInputDevice(MidiInputDevice *pDevice);
75    
76                /**
77                 * Connect this sampler channel to and MIDI input port.
78                 *
79                 * @param MidiPort - MIDI port to connect to
80                 */
81                void SetMidiInputPort(int MidiPort);
82    
83                /**
84                 * Connect this sampler channel to and MIDI input channel.
85                 *
86                 * @param MidiChannel - MIDI channel to connect to
87                 */
88                void SetMidiInputChannel(MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel);
89    
90                /**
91                 * Connect this sampler channel to a MIDI input triplet.
92                 *
93                 * @param pDevice - MIDI input device to connect to
94                 * @param MidiPort - MIDI port to connect to
95               * @param MidiChannel - optional: MIDI channel on which the               * @param MidiChannel - optional: MIDI channel on which the
96               *                      sampler channel should listen to               *                      sampler channel should listen to
97               *                      (default: listen on all MIDI channels)               *                      (default: listen on all MIDI channels)
98               */               */
99              void SetMidiInputPort(MidiInputDevice* pDevice, int midiPort, MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel = MidiInputDevice::MidiInputPort::midi_chan_all);              void SetMidiInput(MidiInputDevice* pDevice, int MidiPort, MidiInputDevice::MidiInputPort::midi_chan_t MidiChannel = MidiInputDevice::MidiInputPort::midi_chan_all);
100    
101              /**              /**
102               * Returns the engine that was deployed on this sampler channel.               * Returns the engine that was deployed on this sampler channel.
# Line 85  namespace LinuxSampler { Line 106  namespace LinuxSampler {
106              Engine* GetEngine();              Engine* GetEngine();
107    
108              /**              /**
109               * Returns the MIDI input device to which this sampler channel               * Returns the MIDI input channel to which this sampler
110               * is currently connected to.               * channel is currently connected to.
111               *               *
112               * @returns  pointer to MIDI input device or NULL if not               * @returns  The MIDI input channel on which the sampler
113               *           connected               *           channel is listening to.
114                 */
115                MidiInputDevice::MidiInputPort::midi_chan_t GetMidiInputChannel();
116    
117                /**
118                 * Returns the MIDI input port number to which this sampler
119                 * channel is currently connected to.
120                 *
121                 * @returns  MIDI input port number or -1 if not connected
122               */               */
123              MidiInputDevice::MidiInputPort* GetMidiInputPort();              int GetMidiInputPort();
124    
125              /**              /**
126               * Returns the audio output device to which this sampler channel               * Returns the audio output device to which this sampler channel
# Line 103  namespace LinuxSampler { Line 132  namespace LinuxSampler {
132              AudioOutputDevice* GetAudioOutputDevice();              AudioOutputDevice* GetAudioOutputDevice();
133    
134              /**              /**
135               * Returns the audio output device to which this sampler channel               * Returns the MIDI input device to which this sampler channel
136               * is currently connected to.               * is currently connected to.
137               *               *
138               * @returns  pointer to audio output device or NULL if not               * @returns  pointer to MIDI input device or NULL if not
139               *           connected               *           connected
140               */               */
141              MidiInputDevice* GetMidiInputDevice();              MidiInputDevice* GetMidiInputDevice();
# Line 117  namespace LinuxSampler { Line 146  namespace LinuxSampler {
146               */               */
147              uint Index();              uint Index();
148    
             /**  
              * Returns midi channel  
              */  
             MidiInputDevice::MidiInputPort::midi_chan_t GetMidiInputChannel() { return midiChannel; }  
   
149          protected:          protected:
150              SamplerChannel(Sampler* pS);              SamplerChannel(Sampler* pS);
151             ~SamplerChannel();             ~SamplerChannel();
152    
153                /** Getting MIDI input device port given its index number. */
154                MidiInputDevice::MidiInputPort* GetMidiInputDevicePort(int MidiPort);
155    
156              Sampler*           pSampler;              Sampler*           pSampler;
157              Engine*            pEngine;              Engine*            pEngine;
             MidiInputDevice::MidiInputPort*     pMidiInputPort;  
158              AudioOutputDevice* pAudioOutputDevice;              AudioOutputDevice* pAudioOutputDevice;
159                MidiInputDevice*   pMidiInputDevice;
160                int                midiPort;
161                MidiInputDevice::MidiInputPort::midi_chan_t midiChannel;
162              int                iIndex;              int                iIndex;
             MidiInputDevice::MidiInputPort::midi_chan_t midiChannel;  
163    
164              friend class Sampler;              friend class Sampler;
165      };      };
# Line 202  namespace LinuxSampler { Line 230  namespace LinuxSampler {
230              uint SamplerChannels();              uint SamplerChannels();
231    
232              /**              /**
233               * Create and add a new sampler channel to this Sampler instance.               * Create and add a new sampler channel to this Sampler
234                 * instance. For race condition reasons the new channel will use
235                 * an index past the last already existing sampler channel
236                 * index (in case the index limit was not reached yet, otherwise
237                 * a free index starting from 0 is searched).
238               *               *
239               * @returns  pointer to new sampler channel               * @returns  pointer to new sampler channel
240               */               */
# Line 217  namespace LinuxSampler { Line 249  namespace LinuxSampler {
249              SamplerChannel* GetSamplerChannel(uint uiSamplerChannel);              SamplerChannel* GetSamplerChannel(uint uiSamplerChannel);
250    
251              /**              /**
252                 * Returns all created sampler channels.
253                 */
254                std::map<uint, SamplerChannel*> GetSamplerChannels();
255    
256                /**
257               * Destroy and remove the given sampler channel from this               * Destroy and remove the given sampler channel from this
258               * Sampler instance.               * Sampler instance.
259               *               *
# Line 233  namespace LinuxSampler { Line 270  namespace LinuxSampler {
270               */               */
271              void RemoveSamplerChannel(uint uiSamplerChannel);              void RemoveSamplerChannel(uint uiSamplerChannel);
272    
273                /**
274                 * Returns the names of all available audio output drivers.
275                 */
276              std::vector<String> AvailableAudioOutputDrivers();              std::vector<String> AvailableAudioOutputDrivers();
277    
278              /**              /**
# Line 257  namespace LinuxSampler { Line 297  namespace LinuxSampler {
297               */               */
298              MidiInputDevice* CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);              MidiInputDevice* CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);
299    
300                /**
301                 * Returns the number of all created audio output devices.
302                 */
303              uint AudioOutputDevices();              uint AudioOutputDevices();
304    
305                /**
306                 * Returns the number of all created MIDI input devices.
307                 */
308              uint MidiInputDevices();              uint MidiInputDevices();
309    
310                /**
311                 * Returns all created audio output devices.
312                 */
313              std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();              std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();
314    
315                /**
316                 * Returns all created MIDI input devices.
317                 */
318              std::map<uint, MidiInputDevice*> GetMidiInputDevices();              std::map<uint, MidiInputDevice*> GetMidiInputDevices();
319    
320                /**
321                 * Destroy the given audio output device and takes care if there
322                 * are still sampler angines connected to this device, etc.
323                 *
324                 * @throws LinuxSamplerException  if sampler channels are still
325                 *                                connected to the device
326                 */
327              void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException);              void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException);
328              void DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException);  
329                /**
330                 * Destroy the given MIDI input device and takes care if there
331                 * are still sampler angines connected to this device, etc.
332                 *
333                 * @throws LinuxSamplerException  if sampler channels are still
334                 *                                connected to the device
335                 */
336                void DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException);
337    
338                /**
339                 * Reset the whole sampler. Destroy all engines, sampler
340                 * channels, MIDI input devices and audio output devices.
341                 */
342                void Reset();
343    
344          protected:          protected:
345              typedef std::map<uint, AudioOutputDevice*> AudioOutputDeviceMap;              typedef std::map<uint, AudioOutputDevice*> AudioOutputDeviceMap;
346              typedef std::map<uint, MidiInputDevice*> MidiInputDeviceMap;              typedef std::map<uint, MidiInputDevice*> MidiInputDeviceMap;
347                typedef std::map<uint, SamplerChannel*> SamplerChannelMap;
348    
349              std::vector<SamplerChannel*> vSamplerChannels;   ///< contains all created sampler channels              SamplerChannelMap     mSamplerChannels;    ///< contains all created sampler channels
350              AudioOutputDeviceMap         mAudioOutputDevices; ///< contains all created audio output devices              AudioOutputDeviceMap  mAudioOutputDevices; ///< contains all created audio output devices
351              MidiInputDeviceMap           mMidiInputDevices;              MidiInputDeviceMap    mMidiInputDevices;   ///< contains all created MIDI input devices
   
             template<class T> inline String ToString(T o) {  
                 std::stringstream ss;  
                 ss << o;  
                 return ss.str();  
             }  
352    
353              friend class SamplerChannel;              friend class SamplerChannel;
354      };      };
Legend:
Removed from v.155  
changed lines
  Added in v.212
  ViewVC Help
Powered by ViewVC