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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2375 - (show annotations) (download) (as text)
Thu Oct 4 17:45:22 2012 UTC (7 years ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 31808 byte(s)
* Added new C++ API method Sampler::GetGlobalMaxVoices().
* Added new C++ API method Sampler::GetGlobalMaxStreams().
* Added new C++ API method Sampler::SetGlobalMaxVoices().
* Added new C++ API method Sampler::SetGlobalMaxStreams().
* CoreMIDI: remove ports that disappeared on the OS from
  the internal list of port bindings
* Fixed erroneous piping of error message in
  src/engines/common/VoiceBase.h (labelled "Disk stream not
  available in time").

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2012 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 "EventListeners.h"
30 #include "common/global.h"
31 #include "common/Exception.h"
32 #include "engines/EngineChannel.h"
33 #include "drivers/midi/MidiInputDevice.h"
34 #include "drivers/audio/AudioOutputDevice.h"
35
36 namespace LinuxSampler {
37
38 // just symbol prototyping
39 class Sampler;
40
41 /** @brief LinuxSampler sampler channel
42 *
43 * Encapsulates a channel of a specific sampler engine type, one
44 * connection to a MIDI input device and one connection to an audio
45 * output device. You cannot create an instance of this class on your
46 * own, you have to use the AddSamplerChannel() method of the Sampler
47 * object to create a new sampler channel.
48 */
49 class SamplerChannel {
50 public:
51 /**
52 * Assign a sampler engine type to this sampler channel.
53 *
54 * @param EngineType - type of the engine to use
55 * @throws Exception - if \a EngineType is invalid
56 * @see Sampler::AvailableEngineTypes()
57 */
58 void SetEngineType(String EngineType) throw (Exception);
59
60 /**
61 * Connect this sampler channel to an audio output device, that
62 * is an instance of an audio output driver. If this sampler
63 * channel was already connected to an audio output device, then
64 * the old connection will automatically be removed before.
65 *
66 * @param pDevice - audio output device to connect to
67 * @throws Exception in case the audio device is tried to be
68 * changed while the sampler channel is used by a
69 * host plugin (e.g. VST, AU, DSSI, LV2) which
70 * don't allow to change the audio output device
71 */
72 void SetAudioOutputDevice(AudioOutputDevice* pDevice) throw (Exception);
73
74 /**
75 * Connect this sampler channel to a MIDI input device.
76 *
77 * @param pDevice - MIDI input device to connect to
78 * @throws Exception in case the MIDI device is tried to be changed
79 * while the sampler channel is being used by a
80 * host plugin (e.g. VST, AU, DSSI, LV2) which
81 * don't allow to change the MIDI port or even
82 * device
83 */
84 void SetMidiInputDevice(MidiInputDevice *pDevice) throw (Exception);
85
86 /**
87 * Connect this sampler channel to a MIDI input port.
88 *
89 * @param MidiPort - MIDI port to connect to
90 * @throws Exception in case the MIDI port is tried to be changed
91 * while the sampler channel is being used by a
92 * host plugin (e.g. VST, AU, DSSI, LV2) which
93 * don't allow to change the MIDI port
94 */
95 void SetMidiInputPort(int MidiPort) throw (Exception);
96
97 /**
98 * Define on which MIDI channel(s) this sampler channel should
99 * listen to. By default, that is after creation of a new
100 * sampler channel, the sampler channel will listen to all MIDI
101 * channels.
102 *
103 * @param MidiChannel - MIDI channel to listen
104 */
105 void SetMidiInputChannel(midi_chan_t MidiChannel);
106
107 /**
108 * Connect this sampler channel to a MIDI input triplet.
109 *
110 * @param pDevice - MIDI input device to connect to
111 * @param iMidiPort - MIDI port to connect to
112 * @param MidiChannel - optional: MIDI channel on which the
113 * sampler channel should listen to
114 * (default: listen on all MIDI channels)
115 * @throws Exception in case the MIDI port is tried to be changed
116 * while the sampler channel is being used by a
117 * host plugin (e.g. VST, AU, DSSI, LV2) which
118 * don't allow to change the MIDI port
119 */
120 void SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, midi_chan_t MidiChannel = midi_chan_all) throw (Exception);
121
122 /**
123 * Returns the EngineChannel object that was deployed on this
124 * sampler channel appropriate to the given sampler engine type.
125 *
126 * @returns pointer to engine or NULL if no engine deployed
127 */
128 EngineChannel* GetEngineChannel();
129
130 /**
131 * Returns the MIDI input channel to which this sampler
132 * channel is currently connected to.
133 *
134 * @returns The MIDI input channel on which the sampler
135 * channel is listening to.
136 */
137 midi_chan_t GetMidiInputChannel();
138
139 /**
140 * Returns the MIDI input port number to which this sampler
141 * channel is currently connected to.
142 *
143 * @returns MIDI input port number or -1 if not connected
144 */
145 int GetMidiInputPort();
146
147 /**
148 * Returns the audio output device to which this sampler channel
149 * is currently connected to.
150 *
151 * @returns pointer to audio output device or NULL if not
152 * connected
153 */
154 AudioOutputDevice* GetAudioOutputDevice();
155
156 /**
157 * Returns the MIDI input device to which this sampler channel
158 * is currently connected to.
159 *
160 * @returns pointer to MIDI input device or NULL if not
161 * connected
162 */
163 MidiInputDevice* GetMidiInputDevice();
164
165 /**
166 * Returns the index number of this sampler channel within the
167 * Sampler instance.
168 */
169 uint Index();
170
171 /** Returns the sampler to which this channel belongs */
172 Sampler* GetSampler();
173
174 ///////////////////////////////////////////////////////////////
175 // Event Listener methods
176
177 /**
178 * Registers the specified listener to be notified
179 * when the engine type of this sampler channel is changed.
180 */
181 void AddEngineChangeListener(EngineChangeListener* l);
182
183 /**
184 * Removes the specified listener.
185 */
186 void RemoveEngineChangeListener(EngineChangeListener* l);
187
188 /**
189 * Removes the specified listener.
190 */
191 void RemoveAllEngineChangeListeners();
192
193 /**
194 * Notifies listeners that the engine type of this sampler
195 * channel is going to be changed soon.
196 */
197 void fireEngineToBeChanged();
198
199 /**
200 * Notifies listeners that the engine
201 * type of this sampler channel is changed.
202 */
203 void fireEngineChanged();
204
205
206 protected:
207 SamplerChannel(Sampler* pS);
208 virtual ~SamplerChannel();
209
210 /** Getting MIDI input device port given its index number. */
211 MidiInputPort* __GetMidiInputDevicePort(int iMidiPort);
212
213 Sampler* pSampler;
214 EngineChannel* pEngineChannel;
215 AudioOutputDevice* pAudioOutputDevice;
216 MidiInputDevice* pMidiInputDevice;
217 int iIndex;
218
219 friend class Sampler;
220 private:
221 int iMidiPort; ///< Don't access directly, read GetMidiInputPort() instead !
222 midi_chan_t midiChannel; ///< Don't access directly, read GetMidiInputChannel() instead !
223 ListenerList<EngineChangeListener*> llEngineChangeListeners;
224 };
225
226 /** @brief LinuxSampler main class
227 *
228 * This is the toplevel class for a LinuxSampler instance.
229 *
230 * LinuxSampler can have arbitrary numbers of sampler channels. Each
231 * sampler channel can individually be deployed with it's own sampler
232 * engine, connected to an arbitrary MIDI input device and connected to
233 * an arbitrary audio output device. Here an example setup:
234 * @code
235 * S.Channel MIDI in S.Engine Audio out
236 * -------------------------------------------------------------------
237 * 0 Alsa -> gig::Engine -> Jack
238 * 1 VSTi -> Akai::Engine -> VSTi
239 * 2 Jack -> DLS::Engine -> Jack
240 * 3 Jack -> SF::Engine -> Alsa
241 *
242 * ... (and so on) ...
243 * @endcode
244 *
245 * Note that not all audio and MIDI backends and sampler engines listed
246 * in the example above might already been implemented!
247 *
248 * As you can see in the example setup, LinuxSampler is capable to use
249 * several, different audio output and MIDI input systems
250 * simultaniously at the same time. Here the example setup shown in the
251 * aspect of MIDI input and audio output devices / drivers:
252 * @code
253 * ######################### #########################
254 * # AudioOutputDeviceJack # # AudioOutputDeviceVSTi #
255 * ######################### #########################
256 * ^ ^ ^
257 * /------------>|Sampler Channel 0|-----/ | |
258 * | /--------->|Sampler Channel 1|---------------------/
259 * | | /------>|Sampler Channel 2|---------/
260 * | | | /--->|Sampler Channel 3|------------>#########################
261 * | | | | ... (and so on) ... # AudioOutputDeviceAlsa #
262 * | | | | #########################
263 * | | | \-----------------------------------------------------\
264 * | | \--------------------------------------------\ |
265 * | \--------------------\ | |
266 * | | | |
267 * ####################### ####################### #######################
268 * # MidiInputDeviceAlsa # # MidiInputDeviceVSTi # # MidiInputDeviceJack #
269 * ####################### ####################### #######################
270 * @endcode
271 *
272 * As you can see in this example setup, one device (that is midi input
273 * driver / audio output driver) can be connected multiple times to
274 * different sampler channels.
275 *
276 * It's even possible to create multiple instances of the same driver, for
277 * example multiple instances of the Alsa output driver to use multiple
278 * sound cards at the same time, or multiple instances of the JACK audio
279 * output driver to leverage SMP systems or boxes with several hard discs.
280 */
281 class Sampler {
282 public:
283 /**
284 * Constructor. Create a LinuxSampler instance.
285 */
286 Sampler();
287
288 /**
289 * Destructor.
290 */
291 virtual ~Sampler();
292
293 /**
294 * Returns the number of sampler channels currently allocated.
295 */
296 uint SamplerChannels();
297
298 /**
299 * Create and add a new sampler channel to this Sampler
300 * instance. For race condition reasons the new channel will use
301 * an index past the last already existing sampler channel
302 * index (in case the index limit was not reached yet, otherwise
303 * a free index starting from 0 is searched).
304 *
305 * @returns pointer to new sampler channel
306 */
307 SamplerChannel* AddSamplerChannel();
308
309 /**
310 * Returns the sampler channel of the given sampler channel
311 * index.
312 *
313 * @returns pointer to sought sampler channel
314 */
315 SamplerChannel* GetSamplerChannel(uint uiSamplerChannel);
316
317 /**
318 * Returns all created sampler channels.
319 */
320 std::map<uint, SamplerChannel*> GetSamplerChannels();
321
322 /**
323 * Destroy and remove the given sampler channel from this
324 * Sampler instance.
325 *
326 * @param pSamplerChannel - pointer to sampler channel to remove
327 */
328 void RemoveSamplerChannel(SamplerChannel* pSamplerChannel);
329
330 /**
331 * Destroy and remove the given sampler channel from this
332 * Sampler instance.
333 *
334 * @param uiSamplerChannel - index of the sampler channel to
335 * remove
336 */
337 void RemoveSamplerChannel(uint uiSamplerChannel);
338
339 /**
340 * Destroy and remove all sampler channels from this
341 * Sampler instance.
342 */
343 void RemoveAllSamplerChannels();
344
345 /**
346 * Returns the names of all available audio output drivers.
347 */
348 std::vector<String> AvailableAudioOutputDrivers();
349
350 /**
351 * Returns the names of all available MIDI input drivers.
352 */
353 std::vector<String> AvailableMidiInputDrivers();
354
355 /**
356 * Returns the names of all available sampler engine types.
357 * @see SamplerChannel::SetEngineType()
358 */
359 std::vector<String> AvailableEngineTypes();
360
361 /**
362 * Create an audio output device.
363 *
364 * @param AudioDriver - name of the audio driver
365 * @param Parameters - eventually needed driver parameters to
366 * create the device
367 * @returns pointer to created audio output device
368 * @throws Exception if device could not be created
369 */
370 AudioOutputDevice* CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (Exception);
371
372 /**
373 * Create a midi input device.
374 *
375 * @param MidiDriver - name of the midi driver
376 * @param Parameters - eventually needed driver parameters to
377 * create the device
378 * @returns pointer to created midi input device
379 * @throws Exception if device could not be created
380 */
381 MidiInputDevice* CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (Exception);
382
383 /**
384 * Returns the number of all created audio output devices.
385 */
386 uint AudioOutputDevices();
387
388 /**
389 * Returns the number of all created MIDI input devices.
390 */
391 uint MidiInputDevices();
392
393 /**
394 * Returns all created audio output devices.
395 */
396 std::map<uint, AudioOutputDevice*> GetAudioOutputDevices();
397
398 /**
399 * Returns all created MIDI input devices.
400 */
401 std::map<uint, MidiInputDevice*> GetMidiInputDevices();
402
403 /**
404 * Destroy the given audio output device and takes care if there
405 * are still sampler engines connected to this device, etc.
406 *
407 * @throws Exception if sampler channels are still
408 * connected to the device
409 */
410 void DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (Exception);
411
412 /**
413 * Destroy all audio output devices and takes care if there
414 * are still sampler engines connected to devices, etc.
415 *
416 * Note: non-autonomous devices, that is devices associated with
417 * host plugin instances like VST, AU, DSSI, LV2 are not
418 * destroyed by this method.
419 *
420 * @throws Exception if sampler channels are still
421 * connected to device
422 */
423 void DestroyAllAudioOutputDevices() throw (Exception);
424
425 /**
426 * Destroy the given MIDI input device and takes care if there
427 * are still sampler engines connected to this device, etc.
428 *
429 * @throws Exception if sampler channels are still
430 * connected to the device
431 */
432 void DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (Exception);
433
434 /**
435 * Destroy all MIDI input devices and take care if there
436 * are still sampler engines connected to device, etc.
437 *
438 * Note: non-autonomous devices, that is devices associated with
439 * host plugin instances like VST, AU, DSSI, LV2 are not
440 * destroyed by this method.
441 *
442 * @throws Exception if sampler channels are still
443 * connected to device
444 */
445 void DestroyAllMidiInputDevices() throw (Exception);
446
447 /**
448 * Gets the current number of all active streams.
449 * @returns The current number of all active streams.
450 */
451 int GetDiskStreamCount();
452
453 /**
454 * Gets the current number of all active voices.
455 * @returns The current number of all active voices.
456 */
457 int GetVoiceCount();
458
459 /**
460 * @see SetGlobalMaxVoices()
461 */
462 int GetGlobalMaxVoices();
463
464 /**
465 * @see SetGlobalMaxStreams()
466 */
467 int GetGlobalMaxStreams();
468
469 /**
470 * Sets the global maximum amount limit of voices.
471 *
472 * Note that this voice limit can also be altered for
473 * each sampler engine instance individually instead.
474 *
475 * @throws Exception if \a n is invalid
476 */
477 void SetGlobalMaxVoices(int n) throw (Exception);
478
479 /**
480 * Sets the global maximum amount limit of disk streams.
481 *
482 * Note that this stream limit can also be altered for
483 * each sampler engine instance individually instead.
484 *
485 * @throws Exception if \a n is invalid
486 */
487 void SetGlobalMaxStreams(int n) throw (Exception);
488
489 /**
490 * Reset the whole sampler. Destroy all engines, sampler
491 * channels, MIDI input devices and audio output devices.
492 */
493 void Reset();
494
495 ///////////////////////////////////////////////////////////////
496 // Event Listener methods
497
498 /**
499 * Registers the specified listener to be notified
500 * when the number of sampler chanels is changed.
501 */
502 void AddChannelCountListener(ChannelCountListener* l);
503
504 /**
505 * Removes the specified listener.
506 */
507 void RemoveChannelCountListener(ChannelCountListener* l);
508
509 /**
510 * Registers the specified listener to be notified
511 * when the number of audio output devices is changed.
512 */
513 void AddAudioDeviceCountListener(AudioDeviceCountListener* l);
514
515 /**
516 * Removes the specified listener.
517 */
518 void RemoveAudioDeviceCountListener(AudioDeviceCountListener* l);
519
520 /**
521 * Registers the specified listener to be notified
522 * when the number of MIDI input devices is changed.
523 */
524 void AddMidiDeviceCountListener(MidiDeviceCountListener* l);
525
526 /**
527 * Removes the specified listener.
528 */
529 void RemoveMidiDeviceCountListener(MidiDeviceCountListener* l);
530
531 /**
532 * Registers the specified listener to be notified when the number
533 * of active voices in a particular sampler channel is changed.
534 */
535 void AddVoiceCountListener(VoiceCountListener* l);
536
537 /**
538 * Removes the specified listener.
539 */
540 void RemoveVoiceCountListener(VoiceCountListener* l);
541
542 /**
543 * Notifies listeners that the number of active voices
544 * on the specified sampler channel is changed.
545 * @param ChannelId The numerical ID of the sampler channel.
546 * @param NewCount The new number of active voices.
547 */
548 void fireVoiceCountChanged(int ChannelId, int NewCount);
549
550 /**
551 * Registers the specified listener to be notified when the number
552 * of active disk streams in a particular sampler channel is changed.
553 */
554 void AddStreamCountListener(StreamCountListener* l);
555
556 /**
557 * Removes the specified listener.
558 */
559 void RemoveStreamCountListener(StreamCountListener* l);
560
561 /**
562 * Notifies listeners that the number of active disk streams
563 * on the specified sampler channel is changed.
564 * @param ChannelId The numerical ID of the sampler channel.
565 * @param NewCount The new number of active disk streams.
566 */
567 void fireStreamCountChanged(int ChannelId, int NewCount);
568
569 /**
570 * Registers the specified listener to be
571 * notified when the fill state of the disk stream
572 * buffers on a specific sampler channel is changed.
573 */
574 void AddBufferFillListener(BufferFillListener* l);
575
576 /**
577 * Removes the specified listener.
578 */
579 void RemoveBufferFillListener(BufferFillListener* l);
580
581 /**
582 * Notifies listeners that the fill state of the disk stream
583 * buffers on the specified sampler channel is changed.
584 * @param ChannelId The numerical ID of the sampler channel.
585 * @param FillData The buffer fill data for the specified sampler channel.
586 */
587 void fireBufferFillChanged(int ChannelId, String FillData);
588
589 /**
590 * Registers the specified listener to be notified
591 * when total number of active voices is changed.
592 */
593 void AddTotalVoiceCountListener(TotalVoiceCountListener* l);
594
595 /**
596 * Removes the specified listener.
597 */
598 void RemoveTotalVoiceCountListener(TotalVoiceCountListener* l);
599
600 /**
601 * Notifies listeners that the total number of active voices is changed.
602 * @param NewCount The new number of active voices.
603 */
604 void fireTotalVoiceCountChanged(int NewCount);
605
606 /**
607 * Registers the specified listener to be notified when the number
608 * of total streams is changed.
609 */
610 void AddTotalStreamCountListener(TotalStreamCountListener* l);
611
612 /**
613 * Removes the specified listener.
614 */
615 void RemoveTotalStreamCountListener(TotalStreamCountListener* l);
616
617 /**
618 * Notifies listeners that the total number of total streams changed.
619 * @param NewCount The new number of total streams.
620 */
621 void fireTotalStreamCountChanged(int NewCount);
622
623 /**
624 * Registers the specified listener to be notified when the number
625 * of effect sends on a particular sampler channel is changed.
626 */
627 void AddFxSendCountListener(FxSendCountListener* l);
628
629 /**
630 * Removes the specified listener.
631 */
632 void RemoveFxSendCountListener(FxSendCountListener* l);
633
634 /**
635 * Notifies listeners about the current number of voices,
636 * streams and total voices, and the current fill state of
637 * the disk stream buffers.
638 */
639 void fireStatistics();
640
641 ///////////////////////////////////////////////////////////////
642 // system specific methods
643
644 /**
645 * Advise the FPU to treat denormal floating point numbers as
646 * zero, to avoid severe performance penalty when dealing with
647 * such extreme floating point values.
648 *
649 * @returns @c true if FPU supports it, @c false otherwise
650 */
651 static bool EnableDenormalsAreZeroMode();
652
653 #if defined(WIN32)
654 /**
655 * Gets the directory where the liblinuxsampler dll is located.
656 * Note: this method is currently only available for Windows.
657 * @returns installation directory
658 */
659 static String GetInstallDir();
660 #endif
661 protected:
662 /**
663 * Notifies listeners that the number of sampler channels has been changed.
664 * @param NewCount The new number of sampler channels.
665 */
666 void fireChannelCountChanged(int NewCount);
667
668 /**
669 * Notifies listeners that the specified sampler channel has just
670 * been added.
671 * @param pChannel The new sampler channel.
672 */
673 void fireChannelAdded(SamplerChannel* pChannel);
674
675 /**
676 * Notifies listeners that the specified sampler channel is
677 * going to be removed soon.
678 * @param pChannel sampler channel to be removed.
679 */
680 void fireChannelToBeRemoved(SamplerChannel* pChannel);
681
682 /**
683 * Notifies listeners that the number of audio output devices has been changed.
684 * @param NewCount The new number of audio output devices.
685 */
686 void fireAudioDeviceCountChanged(int NewCount);
687
688 /**
689 * Notifies listeners that the number of MIDI input devices has been changed.
690 * @param NewCount The new number of MIDI input devices.
691 */
692 void fireMidiDeviceCountChanged(int NewCount);
693
694 /**
695 * Notifies listeners that the supplied MIDI input device is
696 * going to be destroyed soon.
697 * @param pDevice MIDI input device to be destroyed
698 */
699 void fireMidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
700
701 /**
702 * Notifies listeners that the supplied MIDI input device was
703 * just created.
704 * @param pDevice new MIDI input device
705 */
706 void fireMidiDeviceCreated(MidiInputDevice* pDevice);
707
708 /**
709 * Notifies listeners that the number of effect sends
710 * on a particular sampler channel is changed.
711 * @param ChannelId The numerical ID of the sampler channel.
712 * @param NewCount The new number of sampler channels.
713 */
714 void fireFxSendCountChanged(int ChannelId, int NewCount);
715
716 typedef std::map<uint, SamplerChannel*> SamplerChannelMap;
717
718 SamplerChannelMap mSamplerChannels; ///< contains all created sampler channels
719
720 // statistics cache
721 uint uiOldTotalVoiceCount;
722 uint uiOldTotalStreamCount;
723 std::map<uint, uint> mOldVoiceCounts;
724 std::map<uint, uint> mOldStreamCounts;
725
726 friend class SamplerChannel;
727
728 private:
729 ListenerList<ChannelCountListener*> llChannelCountListeners;
730 ListenerList<AudioDeviceCountListener*> llAudioDeviceCountListeners;
731 ListenerList<MidiDeviceCountListener*> llMidiDeviceCountListeners;
732 ListenerList<VoiceCountListener*> llVoiceCountListeners;
733 ListenerList<StreamCountListener*> llStreamCountListeners;
734 ListenerList<BufferFillListener*> llBufferFillListeners;
735 ListenerList<TotalStreamCountListener*> llTotalStreamCountListeners;
736 ListenerList<TotalVoiceCountListener*> llTotalVoiceCountListeners;
737 ListenerList<FxSendCountListener*> llFxSendCountListeners;
738
739 class EventHandler : public EngineChangeListener, public FxSendCountListener {
740 public:
741 void SetSampler(Sampler* pSampler) { this->pSampler = pSampler; }
742
743 /**
744 * Invoked when the engine type of the specified sampler
745 * channel is going to be changed soon.
746 * @param ChannelId The numerical ID of the sampler channel
747 */
748 virtual void EngineToBeChanged(int ChannelId);
749
750 /**
751 * Invoked when the engine type of the
752 * specified sampler channel is changed.
753 * @param ChannelId The numerical ID of the sampler
754 * channel, which engine type has been changed.
755 */
756 virtual void EngineChanged(int ChannelId);
757
758 /**
759 * Invoked when the number of effect sends
760 * on the specified sampler channel has changed.
761 * @param ChannelId The numerical ID of the sampler channel.
762 * @param NewCount The new number of effect sends.
763 */
764 virtual void FxSendCountChanged(int ChannelId, int NewCount);
765
766 private:
767 Sampler* pSampler;
768 } eventHandler;
769 };
770 }
771
772 #endif // __LS_SAMPLER_H__

  ViewVC Help
Powered by ViewVC