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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1937 - (show annotations) (download) (as text)
Sun Jul 12 19:52:20 2009 UTC (14 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 30837 byte(s) 
* bugfix: don't allow to change the audio output device, MIDI input device
  or MIDI input port when using a host plugin implementation
  (e.g VST, AU, DSSI, LV2) as this would go terribly wrong
1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2009 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 * Reset the whole sampler. Destroy all engines, sampler
461 * channels, MIDI input devices and audio output devices.
462 */
463 void Reset();
464
465 ///////////////////////////////////////////////////////////////
466 // Event Listener methods
467
468 /**
469 * Registers the specified listener to be notified
470 * when the number of sampler chanels is changed.
471 */
472 void AddChannelCountListener(ChannelCountListener* l);
473
474 /**
475 * Removes the specified listener.
476 */
477 void RemoveChannelCountListener(ChannelCountListener* l);
478
479 /**
480 * Registers the specified listener to be notified
481 * when the number of audio output devices is changed.
482 */
483 void AddAudioDeviceCountListener(AudioDeviceCountListener* l);
484
485 /**
486 * Removes the specified listener.
487 */
488 void RemoveAudioDeviceCountListener(AudioDeviceCountListener* l);
489
490 /**
491 * Registers the specified listener to be notified
492 * when the number of MIDI input devices is changed.
493 */
494 void AddMidiDeviceCountListener(MidiDeviceCountListener* l);
495
496 /**
497 * Removes the specified listener.
498 */
499 void RemoveMidiDeviceCountListener(MidiDeviceCountListener* l);
500
501 /**
502 * Registers the specified listener to be notified when the number
503 * of active voices in a particular sampler channel is changed.
504 */
505 void AddVoiceCountListener(VoiceCountListener* l);
506
507 /**
508 * Removes the specified listener.
509 */
510 void RemoveVoiceCountListener(VoiceCountListener* l);
511
512 /**
513 * Notifies listeners that the number of active voices
514 * on the specified sampler channel is changed.
515 * @param ChannelId The numerical ID of the sampler channel.
516 * @param NewCount The new number of active voices.
517 */
518 void fireVoiceCountChanged(int ChannelId, int NewCount);
519
520 /**
521 * Registers the specified listener to be notified when the number
522 * of active disk streams in a particular sampler channel is changed.
523 */
524 void AddStreamCountListener(StreamCountListener* l);
525
526 /**
527 * Removes the specified listener.
528 */
529 void RemoveStreamCountListener(StreamCountListener* l);
530
531 /**
532 * Notifies listeners that the number of active disk streams
533 * on the specified sampler channel is changed.
534 * @param ChannelId The numerical ID of the sampler channel.
535 * @param NewCount The new number of active disk streams.
536 */
537 void fireStreamCountChanged(int ChannelId, int NewCount);
538
539 /**
540 * Registers the specified listener to be
541 * notified when the fill state of the disk stream
542 * buffers on a specific sampler channel is changed.
543 */
544 void AddBufferFillListener(BufferFillListener* l);
545
546 /**
547 * Removes the specified listener.
548 */
549 void RemoveBufferFillListener(BufferFillListener* l);
550
551 /**
552 * Notifies listeners that the fill state of the disk stream
553 * buffers on the specified sampler channel is changed.
554 * @param ChannelId The numerical ID of the sampler channel.
555 * @param FillData The buffer fill data for the specified sampler channel.
556 */
557 void fireBufferFillChanged(int ChannelId, String FillData);
558
559 /**
560 * Registers the specified listener to be notified
561 * when total number of active voices is changed.
562 */
563 void AddTotalVoiceCountListener(TotalVoiceCountListener* l);
564
565 /**
566 * Removes the specified listener.
567 */
568 void RemoveTotalVoiceCountListener(TotalVoiceCountListener* l);
569
570 /**
571 * Notifies listeners that the total number of active voices is changed.
572 * @param NewCount The new number of active voices.
573 */
574 void fireTotalVoiceCountChanged(int NewCount);
575
576 /**
577 * Registers the specified listener to be notified when the number
578 * of total streams is changed.
579 */
580 void AddTotalStreamCountListener(TotalStreamCountListener* l);
581
582 /**
583 * Removes the specified listener.
584 */
585 void RemoveTotalStreamCountListener(TotalStreamCountListener* l);
586
587 /**
588 * Notifies listeners that the total number of total streams changed.
589 * @param NewCount The new number of total streams.
590 */
591 void fireTotalStreamCountChanged(int NewCount);
592
593 /**
594 * Registers the specified listener to be notified when the number
595 * of effect sends on a particular sampler channel is changed.
596 */
597 void AddFxSendCountListener(FxSendCountListener* l);
598
599 /**
600 * Removes the specified listener.
601 */
602 void RemoveFxSendCountListener(FxSendCountListener* l);
603
604 /**
605 * Notifies listeners about the current number of voices,
606 * streams and total voices, and the current fill state of
607 * the disk stream buffers.
608 */
609 void fireStatistics();
610
611 ///////////////////////////////////////////////////////////////
612 // system specific methods
613
614 /**
615 * Advise the FPU to treat denormal floating point numbers as
616 * zero, to avoid severe performance penalty when dealing with
617 * such extreme floating point values.
618 *
619 * @returns @c true if FPU supports it, @c false otherwise
620 */
621 static bool EnableDenormalsAreZeroMode();
622
623 #if defined(WIN32)
624 /**
625 * Gets the directory where the liblinuxsampler dll is located.
626 * Note: this method is currently only available for Windows.
627 * @returns installation directory
628 */
629 static String GetInstallDir();
630 #endif
631 protected:
632 /**
633 * Notifies listeners that the number of sampler channels has been changed.
634 * @param NewCount The new number of sampler channels.
635 */
636 void fireChannelCountChanged(int NewCount);
637
638 /**
639 * Notifies listeners that the specified sampler channel has just
640 * been added.
641 * @param pChannel The new sampler channel.
642 */
643 void fireChannelAdded(SamplerChannel* pChannel);
644
645 /**
646 * Notifies listeners that the specified sampler channel is
647 * going to be removed soon.
648 * @param pChannel sampler channel to be removed.
649 */
650 void fireChannelToBeRemoved(SamplerChannel* pChannel);
651
652 /**
653 * Notifies listeners that the number of audio output devices has been changed.
654 * @param NewCount The new number of audio output devices.
655 */
656 void fireAudioDeviceCountChanged(int NewCount);
657
658 /**
659 * Notifies listeners that the number of MIDI input devices has been changed.
660 * @param NewCount The new number of MIDI input devices.
661 */
662 void fireMidiDeviceCountChanged(int NewCount);
663
664 /**
665 * Notifies listeners that the supplied MIDI input device is
666 * going to be destroyed soon.
667 * @param pDevice MIDI input device to be destroyed
668 */
669 void fireMidiDeviceToBeDestroyed(MidiInputDevice* pDevice);
670
671 /**
672 * Notifies listeners that the supplied MIDI input device was
673 * just created.
674 * @param pDevice new MIDI input device
675 */
676 void fireMidiDeviceCreated(MidiInputDevice* pDevice);
677
678 /**
679 * Notifies listeners that the number of effect sends
680 * on a particular sampler channel is changed.
681 * @param ChannelId The numerical ID of the sampler channel.
682 * @param NewCount The new number of sampler channels.
683 */
684 void fireFxSendCountChanged(int ChannelId, int NewCount);
685
686 typedef std::map<uint, SamplerChannel*> SamplerChannelMap;
687
688 SamplerChannelMap mSamplerChannels; ///< contains all created sampler channels
689
690 // statistics cache
691 uint uiOldTotalVoiceCount;
692 uint uiOldTotalStreamCount;
693 std::map<uint, uint> mOldVoiceCounts;
694 std::map<uint, uint> mOldStreamCounts;
695
696 friend class SamplerChannel;
697
698 private:
699 ListenerList<ChannelCountListener*> llChannelCountListeners;
700 ListenerList<AudioDeviceCountListener*> llAudioDeviceCountListeners;
701 ListenerList<MidiDeviceCountListener*> llMidiDeviceCountListeners;
702 ListenerList<VoiceCountListener*> llVoiceCountListeners;
703 ListenerList<StreamCountListener*> llStreamCountListeners;
704 ListenerList<BufferFillListener*> llBufferFillListeners;
705 ListenerList<TotalStreamCountListener*> llTotalStreamCountListeners;
706 ListenerList<TotalVoiceCountListener*> llTotalVoiceCountListeners;
707 ListenerList<FxSendCountListener*> llFxSendCountListeners;
708
709 class EventHandler : public EngineChangeListener, public FxSendCountListener {
710 public:
711 void SetSampler(Sampler* pSampler) { this->pSampler = pSampler; }
712
713 /**
714 * Invoked when the engine type of the specified sampler
715 * channel is going to be changed soon.
716 * @param ChannelId The numerical ID of the sampler channel
717 */
718 virtual void EngineToBeChanged(int ChannelId);
719
720 /**
721 * Invoked when the engine type of the
722 * specified sampler channel is changed.
723 * @param ChannelId The numerical ID of the sampler
724 * channel, which engine type has been changed.
725 */
726 virtual void EngineChanged(int ChannelId);
727
728 /**
729 * Invoked when the number of effect sends
730 * on the specified sampler channel has changed.
731 * @param ChannelId The numerical ID of the sampler channel.
732 * @param NewCount The new number of effect sends.
733 */
734 virtual void FxSendCountChanged(int ChannelId, int NewCount);
735
736 private:
737 Sampler* pSampler;
738 } eventHandler;
739 };
740 }
741
742 #endif // __LS_SAMPLER_H__
  ViewVC Help
Powered by ViewVC