trunk/src/Sampler.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 Christian Schoenebeck                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_SAMPLER_H__
#define __LS_SAMPLER_H__

#include <vector>
#include <map>
#include "common/global.h"
#include "common/LinuxSamplerException.h"
#include "engines/common/EngineChannel.h"
#include "drivers/midi/MidiInputDevice.h"
#include "drivers/audio/AudioOutputDevice.h"

namespace LinuxSampler {

    // just symbol prototyping
    class Sampler;

    /** @brief LinuxSampler sampler channel
     *
     * Encapsulates a channel of a specific sampler engine typ, one
     * connection to a MIDI input device and one connection to an audio
     * output device. You cannot create an instance of this class on your
     * own, you have to use the AddSamplerChannel() method of the Sampler
     * object to create a new sampler channel.
     */
    class SamplerChannel {
        public:
            /**
             * Assign a sampler engine type to this sampler channel.
             *
             * @param EngineType - type of the engine to use
             * @throws LinuxSamplerException - if \a EngineType is invalid
             */
            void SetEngineType(String EngineType) throw (LinuxSamplerException);

            /**
             * Connect this sampler channel to an audio output device, that
             * is an instance of an audio output driver. If this sampler
             * channel was already connected to an audio output device, then
             * the old connection will automatically be removed before.
             *
             * @param pDevice - audio output device to connect to
             */
            void SetAudioOutputDevice(AudioOutputDevice* pDevice);

            /**
             * Connect this sampler channel to a MIDI input device.
             *
             * @param pDevice - MIDI input device to connect to
             */
            void SetMidiInputDevice(MidiInputDevice *pDevice);

            /**
             * Connect this sampler channel to a MIDI input port.
             *
             * @param MidiPort - MIDI port to connect to
             */
            void SetMidiInputPort(int MidiPort);

            /**
             * Define on which MIDI channel(s) this sampler channel should
             * listen to. By default, that is after creation of a new
             * sampler channel, the sampler channel will listen to all MIDI
             * channels.
             *
             * @param MidiChannel - MIDI channel to listen
             */
            void SetMidiInputChannel(midi_chan_t MidiChannel);

            /**
             * Connect this sampler channel to a MIDI input triplet.
             *
             * @param pDevice - MIDI input device to connect to
             * @param iMidiPort - MIDI port to connect to
             * @param MidiChannel - optional: MIDI channel on which the
             *                      sampler channel should listen to
             *                      (default: listen on all MIDI channels)
             */
            void SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, midi_chan_t MidiChannel = midi_chan_all);

            /**
             * Returns the EngineChannel object that was deployed on this
             * sampler channel appropriate to the given sampler engine type.
             *
             * @returns  pointer to engine or NULL if no engine deployed
             */
            EngineChannel* GetEngineChannel();

            /**
             * Returns the MIDI input channel to which this sampler
             * channel is currently connected to.
             *
             * @returns  The MIDI input channel on which the sampler
             *           channel is listening to.
             */
            midi_chan_t GetMidiInputChannel();

            /**
             * Returns the MIDI input port number to which this sampler
             * channel is currently connected to.
             *
             * @returns  MIDI input port number or -1 if not connected
             */
            int GetMidiInputPort();

            /**
             * Returns the audio output device to which this sampler channel
             * is currently connected to.
             *
             * @returns  pointer to audio output device or NULL if not
             *           connected
             */
            AudioOutputDevice* GetAudioOutputDevice();

            /**
             * Returns the MIDI input device to which this sampler channel
             * is currently connected to.
             *
             * @returns  pointer to MIDI input device or NULL if not
             *           connected
             */
            MidiInputDevice* GetMidiInputDevice();

            /**
             * Returns the index number of this sampler channel within the
             * Sampler instance.
             */
            uint Index();

        protected:
            SamplerChannel(Sampler* pS);
            virtual ~SamplerChannel();

            /** Getting MIDI input device port given its index number. */
            MidiInputPort* __GetMidiInputDevicePort(int iMidiPort);
            midi_chan_t    __GetMidiChannel();

            Sampler*           pSampler;
            EngineChannel*     pEngineChannel;
            AudioOutputDevice* pAudioOutputDevice;
            MidiInputDevice*   pMidiInputDevice;
            int                iIndex;

            friend class Sampler;
        private:
            int                iMidiPort;   ///< Don't access directly, read GetMidiInputPort() instead !
            midi_chan_t        midiChannel; ///< Don't access directly, read GetMidiInputChannel() instead !
    };

    /** @brief LinuxSampler main class
     *
     * This is the toplevel class for a LinuxSampler instance.
     *
     * LinuxSampler can have arbitrary numbers of sampler channels. Each
     * sampler channel can individually be deployed with it's own sampler
     * engine, connected to an arbitrary MIDI input device and connected to
     * an arbitrary audio output device. Here an example setup:
     * @code
     * S.Channel.       MIDI in         S.Engine                Audio out
     * -------------------------------------------------------------------
     * 0                Alsa    ->      gig::Engine     ->      Jack
     * 1                VSTi    ->      Akai::Engine    ->      VSTi
     * 2                Jack    ->      DLS::Engine     ->      Jack
     * 3                Jack    ->      SF::Engine      ->      Alsa
     *
     * ... (and so on) ...
     * @endcode
     *
     * Note that not all audio and MIDI backends and sampler engines listed
     * in the example above are already implemented!
     *
     * As you can see in the example setup, LinuxSampler is capable to use
     * several, different audio output and MIDI input systems
     * simultaniously at the same time. Here the example setup shown in the
     * ascpect of MIDI input and audio output devices / drivers:
     * @code
     *                    ######################### #########################
     *                    # AudioOutputDeviceJack # # AudioOutputDeviceVSTi #
     *                    ######################### #########################
     *                                   ^   ^           ^
     *   /------------>|Sampler Channel 0|-----/   |             |
     *   |  /--------->|Sampler Channel 1|---------------------/
     *   |  |    /------>|Sampler Channel 2|---------/
     *   |  |    |  /--->|Sampler Channel 3|------------>#########################
     *   |  |    |  |    ... (and so on) ...             # AudioOutputDeviceAlsa #
     *   |  |    |  |                                    #########################
     *   |  |    |  \-----------------------------------------------------\
     *   |  |    \--------------------------------------------\           |
     *   |  \--------------------\                            |           |
     *   |                         |                          |           |
     * ####################### ####################### #######################
     * # MidiInputDeviceAlsa # # MidiInputDeviceVSTi # # MidiInputDeviceJack #
     * ####################### ####################### #######################
     * @endcode
     *
     * As you can see in this example setup, one device (that is midi input
     * driver / audio output driver) can be connected multiple times to
     * different sampler channels.
     */
    class Sampler {
        public:
            /**
             * Constructor. Create a LinuxSampler instance.
             */
            Sampler();

            /**
             * Destructor.
             */
            virtual ~Sampler();

            /**
             * Returns the number of sampler channels currently allocated.
             */
            uint SamplerChannels();

            /**
             * Create and add a new sampler channel to this Sampler
             * instance. For race condition reasons the new channel will use
             * an index past the last already existing sampler channel
             * index (in case the index limit was not reached yet, otherwise
             * a free index starting from 0 is searched).
             *
             * @returns  pointer to new sampler channel
             */
            SamplerChannel* AddSamplerChannel();

            /**
             * Returns the sampler channel of the given sampler channel
             * index.
             *
             * @returns  pointer to sought sampler channel
             */
            SamplerChannel* GetSamplerChannel(uint uiSamplerChannel);

            /**
             * Returns all created sampler channels.
             */
            std::map<uint, SamplerChannel*> GetSamplerChannels();

            /**
             * Destroy and remove the given sampler channel from this
             * Sampler instance.
             *
             * @param pSamplerChannel - pointer to sampler channel to remove
             */
            void RemoveSamplerChannel(SamplerChannel* pSamplerChannel);

            /**
             * Destroy and remove the given sampler channel from this
             * Sampler instance.
             *
             * @param uiSamplerChannel - index of the sampler channel to
             *                           remove
             */
            void RemoveSamplerChannel(uint uiSamplerChannel);

            /**
             * Returns the names of all available audio output drivers.
             */
            std::vector<String> AvailableAudioOutputDrivers();

            /**
             * Create an audio output device.
             *
             * @param AudioDriver - name of the audio driver
             * @param Parameters - eventually needed driver parameters to
             *                     create the device
             * @returns  pointer to created audio output device
             * @throws LinuxSamplerException  if device could not be created
             */
            AudioOutputDevice* CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);

            /**
             * Create a midi input device.
             *
             * @param MidiDriver - name of the midi driver
             * @param Parameters - eventually needed driver parameters to
             *                     create the device
             * @returns  pointer to created midi input device
             * @throws LinuxSamplerException  if device could not be created
             */
            MidiInputDevice* CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);

            /**
             * Returns the number of all created audio output devices.
             */
            uint AudioOutputDevices();

            /**
             * Returns the number of all created MIDI input devices.
             */
            uint MidiInputDevices();

            /**
             * Returns all created audio output devices.
             */
            std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();

            /**
             * Returns all created MIDI input devices.
             */
            std::map<uint, MidiInputDevice*> GetMidiInputDevices();

            /**
             * Destroy the given audio output device and takes care if there
             * are still sampler angines connected to this device, etc.
             *
             * @throws LinuxSamplerException  if sampler channels are still
             *                                connected to the device
             */
            void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException);

            /**
             * Destroy the given MIDI input device and takes care if there
             * are still sampler angines connected to this device, etc.
             *
             * @throws LinuxSamplerException  if sampler channels are still
             *                                connected to the device
             */
            void DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException);

            /**
             * Reset the whole sampler. Destroy all engines, sampler
             * channels, MIDI input devices and audio output devices.
             */
            void Reset();

        protected:
            typedef std::map<uint, AudioOutputDevice*> AudioOutputDeviceMap;
            typedef std::map<uint, MidiInputDevice*> MidiInputDeviceMap;
            typedef std::map<uint, SamplerChannel*> SamplerChannelMap;

            SamplerChannelMap     mSamplerChannels;    ///< contains all created sampler channels
            AudioOutputDeviceMap  mAudioOutputDevices; ///< contains all created audio output devices
            MidiInputDeviceMap    mMidiInputDevices;   ///< contains all created MIDI input devices

            friend class SamplerChannel;
    };
}

#endif // __LS_SAMPLER_H__
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	411	* Copyright (C) 2005 Christian Schoenebeck *
7	schoenebeck	53	* *
8			* This program is free software; you can redistribute it and/or modify *
9			* 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			* This program is distributed in the hope that it will be useful, *
14			* 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			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#ifndef __LS_SAMPLER_H__
25			#define __LS_SAMPLER_H__
26
27			#include <vector>
28			#include <map>
29			#include "common/global.h"
30			#include "common/LinuxSamplerException.h"
31	schoenebeck	411	#include "engines/common/EngineChannel.h"
32	schoenebeck	203	#include "drivers/midi/MidiInputDevice.h"
33			#include "drivers/audio/AudioOutputDevice.h"
34	schoenebeck	53
35			namespace LinuxSampler {
36
37			// just symbol prototyping
38			class Sampler;
39
40	schoenebeck	411	/** @brief LinuxSampler sampler channel
41	schoenebeck	57	*
42	schoenebeck	411	* Encapsulates a channel of a specific sampler engine typ, one
43			* connection to a MIDI input device and one connection to an audio
44			* output device. You cannot create an instance of this class on your
45			* own, you have to use the AddSamplerChannel() method of the Sampler
46			* object to create a new sampler channel.
47	schoenebeck	57	*/
48	schoenebeck	53	class SamplerChannel {
49			public:
50	schoenebeck	57	/**
51	schoenebeck	411	* Assign a sampler engine type to this sampler channel.
52	schoenebeck	57	*
53	schoenebeck	411	* @param EngineType - type of the engine to use
54			* @throws LinuxSamplerException - if \a EngineType is invalid
55	schoenebeck	57	*/
56	schoenebeck	411	void SetEngineType(String EngineType) throw (LinuxSamplerException);
57	schoenebeck	57
58			/**
59	schoenebeck	123	* Connect this sampler channel to an audio output device, that
60			* is an instance of an audio output driver. If this sampler
61			* channel was already connected to an audio output device, then
62			* the old connection will automatically be removed before.
63	schoenebeck	57	*
64	schoenebeck	123	* @param pDevice - audio output device to connect to
65	schoenebeck	57	*/
66	schoenebeck	123	void SetAudioOutputDevice(AudioOutputDevice* pDevice);
67	schoenebeck	57
68			/**
69	schoenebeck	411	* Connect this sampler channel to a MIDI input device.
70	schoenebeck	57	*
71	capela	159	* @param pDevice - MIDI input device to connect to
72			*/
73			void SetMidiInputDevice(MidiInputDevice *pDevice);
74
75			/**
76	schoenebeck	411	* Connect this sampler channel to a MIDI input port.
77	capela	159	*
78			* @param MidiPort - MIDI port to connect to
79			*/
80			void SetMidiInputPort(int MidiPort);
81
82			/**
83	schoenebeck	411	* Define on which MIDI channel(s) this sampler channel should
84			* listen to. By default, that is after creation of a new
85			* sampler channel, the sampler channel will listen to all MIDI
86			* channels.
87	capela	159	*
88	schoenebeck	411	* @param MidiChannel - MIDI channel to listen
89	capela	159	*/
90	schoenebeck	675	void SetMidiInputChannel(midi_chan_t MidiChannel);
91	capela	159
92			/**
93			* Connect this sampler channel to a MIDI input triplet.
94			*
95			* @param pDevice - MIDI input device to connect to
96	schoenebeck	221	* @param iMidiPort - MIDI port to connect to
97	schoenebeck	57	* @param MidiChannel - optional: MIDI channel on which the
98			* sampler channel should listen to
99			* (default: listen on all MIDI channels)
100			*/
101	schoenebeck	675	void SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, midi_chan_t MidiChannel = midi_chan_all);
102	schoenebeck	57
103			/**
104	schoenebeck	411	* Returns the EngineChannel object that was deployed on this
105			* sampler channel appropriate to the given sampler engine type.
106	schoenebeck	57	*
107			* @returns pointer to engine or NULL if no engine deployed
108			*/
109	schoenebeck	411	EngineChannel* GetEngineChannel();
110	schoenebeck	57
111			/**
112	capela	159	* Returns the MIDI input channel to which this sampler
113			* channel is currently connected to.
114	schoenebeck	57	*
115	capela	159	* @returns The MIDI input channel on which the sampler
116			* channel is listening to.
117	schoenebeck	57	*/
118	schoenebeck	675	midi_chan_t GetMidiInputChannel();
119	schoenebeck	57
120			/**
121	capela	159	* Returns the MIDI input port number to which this sampler
122			* channel is currently connected to.
123			*
124			* @returns MIDI input port number or -1 if not connected
125			*/
126			int GetMidiInputPort();
127
128			/**
129	schoenebeck	57	* Returns the audio output device to which this sampler channel
130			* is currently connected to.
131			*
132			* @returns pointer to audio output device or NULL if not
133			* connected
134			*/
135			AudioOutputDevice* GetAudioOutputDevice();
136
137			/**
138	capela	159	* Returns the MIDI input device to which this sampler channel
139	senkov	155	* is currently connected to.
140			*
141	capela	159	* @returns pointer to MIDI input device or NULL if not
142	senkov	155	* connected
143			*/
144			MidiInputDevice* GetMidiInputDevice();
145
146			/**
147	schoenebeck	57	* Returns the index number of this sampler channel within the
148			* Sampler instance.
149			*/
150			uint Index();
151
152			protected:
153	schoenebeck	53	SamplerChannel(Sampler* pS);
154	letz	502	virtual ~SamplerChannel();
155	schoenebeck	57
156	capela	159	/** Getting MIDI input device port given its index number. */
157	schoenebeck	675	MidiInputPort* __GetMidiInputDevicePort(int iMidiPort);
158			midi_chan_t __GetMidiChannel();
159	schoenebeck	203
160	schoenebeck	53	Sampler* pSampler;
161	schoenebeck	411	EngineChannel* pEngineChannel;
162	schoenebeck	53	AudioOutputDevice* pAudioOutputDevice;
163	capela	159	MidiInputDevice* pMidiInputDevice;
164	schoenebeck	53	int iIndex;
165	schoenebeck	57
166			friend class Sampler;
167	schoenebeck	675	private:
168			int iMidiPort; ///< Don't access directly, read GetMidiInputPort() instead !
169			midi_chan_t midiChannel; ///< Don't access directly, read GetMidiInputChannel() instead !
170	schoenebeck	53	};
171
172	schoenebeck	411	/** @brief LinuxSampler main class
173	schoenebeck	57	*
174			* This is the toplevel class for a LinuxSampler instance.
175			*
176			* LinuxSampler can have arbitrary numbers of sampler channels. Each
177			* sampler channel can individually be deployed with it's own sampler
178			* engine, connected to an arbitrary MIDI input device and connected to
179			* an arbitrary audio output device. Here an example setup:
180	schoenebeck	675	* @code
181			* S.Channel. MIDI in S.Engine Audio out
182			* -------------------------------------------------------------------
183			* 0 Alsa -> gig::Engine -> Jack
184			* 1 VSTi -> Akai::Engine -> VSTi
185			* 2 Jack -> DLS::Engine -> Jack
186			* 3 Jack -> SF::Engine -> Alsa
187	schoenebeck	57	*
188	schoenebeck	675	* ... (and so on) ...
189			* @endcode
190	schoenebeck	57	*
191			* Note that not all audio and MIDI backends and sampler engines listed
192			* in the example above are already implemented!
193			*
194			* As you can see in the example setup, LinuxSampler is capable to use
195			* several, different audio output and MIDI input systems
196			* simultaniously at the same time. Here the example setup shown in the
197			* ascpect of MIDI input and audio output devices / drivers:
198	schoenebeck	675	* @code
199			* ######################### #########################
200			* # AudioOutputDeviceJack # # AudioOutputDeviceVSTi #
201			* ######################### #########################
202			* ^ ^ ^
203			* /------------>\|Sampler Channel 0\|-----/ \| \|
204			* \| /--------->\|Sampler Channel 1\|---------------------/
205			* \| \| /------>\|Sampler Channel 2\|---------/
206			* \| \| \| /--->\|Sampler Channel 3\|------------>#########################
207			* \| \| \| \| ... (and so on) ... # AudioOutputDeviceAlsa #
208			* \| \| \| \| #########################
209			* \| \| \| \-----------------------------------------------------\
210			* \| \| \--------------------------------------------\ \|
211			* \| \--------------------\ \| \|
212			* \| \| \| \|
213			* ####################### ####################### #######################
214			* # MidiInputDeviceAlsa # # MidiInputDeviceVSTi # # MidiInputDeviceJack #
215			* ####################### ####################### #######################
216			* @endcode
217	schoenebeck	57	*
218			* As you can see in this example setup, one device (that is midi input
219			* driver / audio output driver) can be connected multiple times to
220			* different sampler channels.
221			*/
222	schoenebeck	53	class Sampler {
223			public:
224	schoenebeck	57	/**
225			* Constructor. Create a LinuxSampler instance.
226			*/
227	schoenebeck	53	Sampler();
228	schoenebeck	57
229			/**
230			* Destructor.
231			*/
232	letz	502	virtual ~Sampler();
233	schoenebeck	57
234			/**
235			* Returns the number of sampler channels currently allocated.
236			*/
237			uint SamplerChannels();
238
239			/**
240	schoenebeck	209	* Create and add a new sampler channel to this Sampler
241			* instance. For race condition reasons the new channel will use
242			* an index past the last already existing sampler channel
243			* index (in case the index limit was not reached yet, otherwise
244			* a free index starting from 0 is searched).
245	schoenebeck	57	*
246			* @returns pointer to new sampler channel
247			*/
248			SamplerChannel* AddSamplerChannel();
249
250			/**
251			* Returns the sampler channel of the given sampler channel
252			* index.
253			*
254			* @returns pointer to sought sampler channel
255			*/
256			SamplerChannel* GetSamplerChannel(uint uiSamplerChannel);
257
258			/**
259	schoenebeck	209	* Returns all created sampler channels.
260			*/
261			std::map<uint, SamplerChannel*> GetSamplerChannels();
262
263			/**
264	schoenebeck	57	* Destroy and remove the given sampler channel from this
265			* Sampler instance.
266			*
267			* @param pSamplerChannel - pointer to sampler channel to remove
268			*/
269			void RemoveSamplerChannel(SamplerChannel* pSamplerChannel);
270
271			/**
272			* Destroy and remove the given sampler channel from this
273			* Sampler instance.
274			*
275			* @param uiSamplerChannel - index of the sampler channel to
276			* remove
277			*/
278			void RemoveSamplerChannel(uint uiSamplerChannel);
279
280	schoenebeck	209	/**
281			* Returns the names of all available audio output drivers.
282			*/
283	schoenebeck	123	std::vector<String> AvailableAudioOutputDrivers();
284
285	schoenebeck	57	/**
286	senkov	155	* Create an audio output device.
287	schoenebeck	57	*
288	schoenebeck	123	* @param AudioDriver - name of the audio driver
289			* @param Parameters - eventually needed driver parameters to
290			* create the device
291	schoenebeck	57	* @returns pointer to created audio output device
292	schoenebeck	123	* @throws LinuxSamplerException if device could not be created
293	schoenebeck	57	*/
294	schoenebeck	123	AudioOutputDevice* CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);
295	schoenebeck	57
296	senkov	155	/**
297			* Create a midi input device.
298			*
299			* @param MidiDriver - name of the midi driver
300			* @param Parameters - eventually needed driver parameters to
301			* create the device
302			* @returns pointer to created midi input device
303			* @throws LinuxSamplerException if device could not be created
304			*/
305			MidiInputDevice* CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);
306
307	schoenebeck	209	/**
308			* Returns the number of all created audio output devices.
309			*/
310	schoenebeck	123	uint AudioOutputDevices();
311	schoenebeck	209
312			/**
313			* Returns the number of all created MIDI input devices.
314			*/
315	senkov	155	uint MidiInputDevices();
316	schoenebeck	57
317	schoenebeck	209	/**
318			* Returns all created audio output devices.
319			*/
320	schoenebeck	123	std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();
321
322	schoenebeck	209	/**
323			* Returns all created MIDI input devices.
324			*/
325	senkov	155	std::map<uint, MidiInputDevice*> GetMidiInputDevices();
326
327	schoenebeck	209	/**
328			* Destroy the given audio output device and takes care if there
329			* are still sampler angines connected to this device, etc.
330			*
331			* @throws LinuxSamplerException if sampler channels are still
332			* connected to the device
333			*/
334	schoenebeck	123	void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException);
335
336	schoenebeck	209	/**
337			* Destroy the given MIDI input device and takes care if there
338			* are still sampler angines connected to this device, etc.
339			*
340			* @throws LinuxSamplerException if sampler channels are still
341			* connected to the device
342			*/
343			void DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException);
344
345	schoenebeck	212	/**
346			* Reset the whole sampler. Destroy all engines, sampler
347			* channels, MIDI input devices and audio output devices.
348			*/
349			void Reset();
350
351	schoenebeck	53	protected:
352	schoenebeck	123	typedef std::map<uint, AudioOutputDevice*> AudioOutputDeviceMap;
353	senkov	155	typedef std::map<uint, MidiInputDevice*> MidiInputDeviceMap;
354	schoenebeck	209	typedef std::map<uint, SamplerChannel*> SamplerChannelMap;
355	schoenebeck	53
356	schoenebeck	209	SamplerChannelMap mSamplerChannels; ///< contains all created sampler channels
357			AudioOutputDeviceMap mAudioOutputDevices; ///< contains all created audio output devices
358			MidiInputDeviceMap mMidiInputDevices; ///< contains all created MIDI input devices
359	schoenebeck	53
360			friend class SamplerChannel;
361			};
362			}
363
364			#endif // __LS_SAMPLER_H__