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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 675 - (show annotations) (download) (as text)
Wed Jun 22 22:09:28 2005 UTC (16 years, 1 month ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 15263 byte(s)
* update MIDI channel info on program change

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 Christian Schoenebeck *
7 * *
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 #include "engines/common/EngineChannel.h"
32 #include "drivers/midi/MidiInputDevice.h"
33 #include "drivers/audio/AudioOutputDevice.h"
34
35 namespace LinuxSampler {
36
37 // just symbol prototyping
38 class Sampler;
39
40 /** @brief LinuxSampler sampler channel
41 *
42 * 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 */
48 class SamplerChannel {
49 public:
50 /**
51 * Assign a sampler engine type to this sampler channel.
52 *
53 * @param EngineType - type of the engine to use
54 * @throws LinuxSamplerException - if \a EngineType is invalid
55 */
56 void SetEngineType(String EngineType) throw (LinuxSamplerException);
57
58 /**
59 * 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 *
64 * @param pDevice - audio output device to connect to
65 */
66 void SetAudioOutputDevice(AudioOutputDevice* pDevice);
67
68 /**
69 * Connect this sampler channel to a MIDI input device.
70 *
71 * @param pDevice - MIDI input device to connect to
72 */
73 void SetMidiInputDevice(MidiInputDevice *pDevice);
74
75 /**
76 * Connect this sampler channel to a MIDI input port.
77 *
78 * @param MidiPort - MIDI port to connect to
79 */
80 void SetMidiInputPort(int MidiPort);
81
82 /**
83 * 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 *
88 * @param MidiChannel - MIDI channel to listen
89 */
90 void SetMidiInputChannel(midi_chan_t MidiChannel);
91
92 /**
93 * Connect this sampler channel to a MIDI input triplet.
94 *
95 * @param pDevice - MIDI input device to connect to
96 * @param iMidiPort - MIDI port to connect to
97 * @param MidiChannel - optional: MIDI channel on which the
98 * sampler channel should listen to
99 * (default: listen on all MIDI channels)
100 */
101 void SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, midi_chan_t MidiChannel = midi_chan_all);
102
103 /**
104 * Returns the EngineChannel object that was deployed on this
105 * sampler channel appropriate to the given sampler engine type.
106 *
107 * @returns pointer to engine or NULL if no engine deployed
108 */
109 EngineChannel* GetEngineChannel();
110
111 /**
112 * Returns the MIDI input channel to which this sampler
113 * channel is currently connected to.
114 *
115 * @returns The MIDI input channel on which the sampler
116 * channel is listening to.
117 */
118 midi_chan_t GetMidiInputChannel();
119
120 /**
121 * 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 * 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 * Returns the MIDI input device to which this sampler channel
139 * is currently connected to.
140 *
141 * @returns pointer to MIDI input device or NULL if not
142 * connected
143 */
144 MidiInputDevice* GetMidiInputDevice();
145
146 /**
147 * Returns the index number of this sampler channel within the
148 * Sampler instance.
149 */
150 uint Index();
151
152 protected:
153 SamplerChannel(Sampler* pS);
154 virtual ~SamplerChannel();
155
156 /** Getting MIDI input device port given its index number. */
157 MidiInputPort* __GetMidiInputDevicePort(int iMidiPort);
158 midi_chan_t __GetMidiChannel();
159
160 Sampler* pSampler;
161 EngineChannel* pEngineChannel;
162 AudioOutputDevice* pAudioOutputDevice;
163 MidiInputDevice* pMidiInputDevice;
164 int iIndex;
165
166 friend class Sampler;
167 private:
168 int iMidiPort; ///< Don't access directly, read GetMidiInputPort() instead !
169 midi_chan_t midiChannel; ///< Don't access directly, read GetMidiInputChannel() instead !
170 };
171
172 /** @brief LinuxSampler main class
173 *
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 * @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 *
188 * ... (and so on) ...
189 * @endcode
190 *
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 * @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 *
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 class Sampler {
223 public:
224 /**
225 * Constructor. Create a LinuxSampler instance.
226 */
227 Sampler();
228
229 /**
230 * Destructor.
231 */
232 virtual ~Sampler();
233
234 /**
235 * Returns the number of sampler channels currently allocated.
236 */
237 uint SamplerChannels();
238
239 /**
240 * 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 *
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 * Returns all created sampler channels.
260 */
261 std::map<uint, SamplerChannel*> GetSamplerChannels();
262
263 /**
264 * 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 /**
281 * Returns the names of all available audio output drivers.
282 */
283 std::vector<String> AvailableAudioOutputDrivers();
284
285 /**
286 * Create an audio output device.
287 *
288 * @param AudioDriver - name of the audio driver
289 * @param Parameters - eventually needed driver parameters to
290 * create the device
291 * @returns pointer to created audio output device
292 * @throws LinuxSamplerException if device could not be created
293 */
294 AudioOutputDevice* CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (LinuxSamplerException);
295
296 /**
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 /**
308 * Returns the number of all created audio output devices.
309 */
310 uint AudioOutputDevices();
311
312 /**
313 * Returns the number of all created MIDI input devices.
314 */
315 uint MidiInputDevices();
316
317 /**
318 * Returns all created audio output devices.
319 */
320 std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();
321
322 /**
323 * Returns all created MIDI input devices.
324 */
325 std::map<uint, MidiInputDevice*> GetMidiInputDevices();
326
327 /**
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 void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException);
335
336 /**
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 /**
346 * Reset the whole sampler. Destroy all engines, sampler
347 * channels, MIDI input devices and audio output devices.
348 */
349 void Reset();
350
351 protected:
352 typedef std::map<uint, AudioOutputDevice*> AudioOutputDeviceMap;
353 typedef std::map<uint, MidiInputDevice*> MidiInputDeviceMap;
354 typedef std::map<uint, SamplerChannel*> SamplerChannelMap;
355
356 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
360 friend class SamplerChannel;
361 };
362 }
363
364 #endif // __LS_SAMPLER_H__

  ViewVC Help
Powered by ViewVC