engines/common/AbstractVoice.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
 *   Copyright (C) 2005-2008 Christian Schoenebeck                         *
 *   Copyright (C) 2009-2010 Christian Schoenebeck and Grigor Iliev        *
 *                                                                         *
 *   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_ABSTRACTVOICE_H__
#define __LS_ABSTRACTVOICE_H__

#include "Voice.h"

#include "../../common/global_private.h"
#include "../AbstractEngineChannel.h"
#include "../common/LFOBase.h"
#include "../EngineBase.h"
#include "EG.h"
#include "../gig/EGADSR.h"
#include "../gig/EGDecay.h"
#include "../gig/SmoothVolume.h"
#include "../gig/Synthesizer.h"
#include "../gig/Profiler.h"

// include the appropriate (unsigned) triangle LFO implementation
#if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
# include "../common/LFOTriangleIntMath.h"
#elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
# include "../common/LFOTriangleIntAbsMath.h"
#elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
# include "../common/LFOTriangleDiHarmonic.h"
#else
# error "Unknown or no (unsigned) triangle LFO implementation selected!"
#endif

// include the appropriate (signed) triangle LFO implementation
#if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
# include "../common/LFOTriangleIntMath.h"
#elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
# include "../common/LFOTriangleIntAbsMath.h"
#elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
# include "../common/LFOTriangleDiHarmonic.h"
#else
# error "Unknown or no (signed) triangle LFO implementation selected!"
#endif

namespace LinuxSampler {

    #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
    typedef LFOTriangleIntMath<range_unsigned> LFOUnsigned;
    #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
    typedef LFOTriangleIntAbsMath<range_unsigned> LFOUnsigned;
    #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
    typedef LFOTriangleDiHarmonic<range_unsigned> LFOUnsigned;
    #endif

    #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
    typedef LFOTriangleIntMath<range_signed> LFOSigned;
    #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
    typedef LFOTriangleIntAbsMath<range_signed> LFOSigned;
    #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
    typedef LFOTriangleDiHarmonic<range_signed> LFOSigned;
    #endif

    class AbstractVoice : public Voice {
        public:
            type_t       Type;         ///< Voice Type
            int          MIDIKey;      ///< MIDI key number of the key that triggered the voice
            uint         KeyGroup;

            AbstractVoice();
            virtual ~AbstractVoice();

            inline bool IsActive() { return PlaybackState; }
            inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }

            virtual void Reset();

            virtual int Trigger (
                AbstractEngineChannel*  pEngineChannel,
                Pool<Event>::Iterator&  itNoteOnEvent,
                int                     PitchBend,
                type_t                  VoiceType,
                int                     iKeyGroup
            );

            virtual void Synthesize(uint Samples, sample_t* pSrc, uint Skip);

            void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
            void processPitchEvent(RTList<Event>::Iterator& itEvent);
            void processResonanceEvent(RTList<Event>::Iterator& itEvent);
            void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
            void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
            void Kill(Pool<Event>::Iterator& itKillEvent);

            bool                Orphan;             ///< true if this voice is playing a sample from an instrument that is unloaded. When the voice dies, the sample (and dimension region) will be handed back to the instrument resource manager.
            playback_state_t    PlaybackState;      ///< When a sample will be triggered, it will be first played from RAM cache and after a couple of sample points it will switch to disk streaming and at the end of a disk stream we have to add null samples, so the interpolator can do it's work correctly
            Stream::reference_t DiskStreamRef;      ///< Reference / link to the disk stream

            template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;

        protected:
            SampleInfo      SmplInfo;
            RegionInfo      RgnInfo;
            InstrumentInfo  InstrInfo;
            AbstractEngineChannel* pEngineChannel;

            double                      Pos;                ///< Current playback position in sample
            PitchInfo                   Pitch;
            float                       CutoffBase;         ///< Cutoff frequency before control change, EG and LFO are applied
            float                       VolumeLeft;         ///< Left channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
            float                       VolumeRight;        ///< Right channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
            gig::SmoothVolume           CrossfadeSmoother;  ///< Crossfade volume, updated by crossfade CC events
            gig::SmoothVolume           VolumeSmoother;     ///< Volume, updated by CC 7 (volume) events
            gig::SmoothVolume           PanLeftSmoother;    ///< Left channel volume, updated by CC 10 (pan) events
            gig::SmoothVolume           PanRightSmoother;   ///< Right channel volume, updated by CC 10 (pan) events
            bool                        DiskVoice;          ///< If the sample is very short it completely fits into the RAM cache and doesn't need to be streamed from disk, in that case this flag is set to false
            bool                        RAMLoop;            ///< If this voice has a loop defined which completely fits into the cached RAM part of the sample, in this case we handle the looping within the voice class, else if the loop is located in the disk stream part, we let the disk stream handle the looping
            unsigned long               MaxRAMPos;          ///< The upper allowed limit (not actually the end) in the RAM sample cache, after that point it's not safe to chase the interpolator another time over over the current cache position, instead we switch to disk then.
            uint                        Delay;              ///< Number of sample points the rendering process of this voice should be delayed (jitter correction), will be set to 0 after the first audio fragment cycle
            EG*                         pEG1;               ///< Envelope Generator 1 (Amplification)
            gig::EGADSR                 EG2;                ///< Envelope Generator 2 (Filter cutoff frequency) TODO: use common EG instead of gig
            gig::EGDecay                EG3;                ///< Envelope Generator 3 (Pitch) TODO: use common EG instead?
            midi_ctrl                   VCFCutoffCtrl;
            midi_ctrl                   VCFResonanceCtrl;
            LFOUnsigned*                pLFO1;               ///< Low Frequency Oscillator 1 (Amplification)
            LFOUnsigned*                pLFO2;               ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
            LFOSigned*                  pLFO3;               ///< Low Frequency Oscillator 3 (Pitch)
            bool                        bLFO1Enabled;        ///< Should we use the Amplitude LFO for this voice?
            bool                        bLFO2Enabled;        ///< Should we use the Filter Cutoff LFO for this voice?
            bool                        bLFO3Enabled;        ///< Should we use the Pitch LFO for this voice?
            Pool<Event>::Iterator       itTriggerEvent;      ///< First event on the key's list the voice should process (only needed for the first audio fragment in which voice was triggered, after that it will be set to NULL).
            Pool<Event>::Iterator       itKillEvent;         ///< Event which caused this voice to be killed
            int                         SynthesisMode;
            float                       fFinalCutoff;
            float                       fFinalResonance;
            gig::SynthesisParam         finalSynthesisParameters;
            gig::Loop                   loop;


            virtual AbstractEngine* GetEngine() = 0;
            virtual SampleInfo      GetSampleInfo() = 0;
            virtual RegionInfo      GetRegionInfo() = 0;
            virtual InstrumentInfo  GetInstrumentInfo() = 0;

            /**
             * Gets the sample cache size in bytes.
             */
            virtual unsigned long GetSampleCacheSize() = 0;

            /**
             * Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
             * All involved parameters (VelocityResponseCurve, VelocityResponseDepth
             * and VelocityResponseCurveScaling) involved are taken into account to
             * calculate the amplitude factor. Use this method when a key was
             * triggered to get the volume with which the sample should be played
             * back.
             *
             * @param MIDIKeyVelocity  MIDI velocity value of the triggered key (between 0 and 127)
             * @returns                amplitude factor (between 0.0 and 1.0)
             */
            virtual double GetVelocityAttenuation(uint8_t MIDIKeyVelocity) = 0;

            virtual double GetSampleAttenuation() = 0;

            virtual double CalculateVolume(double velocityAttenuation);

            /**
             * Get starting crossfade volume level
             */
            virtual double CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) = 0;

            virtual int   OrderNewStream() = 0;

            virtual PitchInfo CalculatePitchInfo(int PitchBend);

            // TODO: cleanup the interface. The following two methods
            // are maybe not neccessary after the TriggerEG1 method
            // was added.

            /**
             * Get current value of EG1 controller.
             */
            virtual double GetEG1ControllerValue(uint8_t MIDIKeyVelocity) = 0;

            /**
             * Calculate influence of EG1 controller on EG1's parameters.
             */
            virtual EGInfo CalculateEG1ControllerInfluence(double eg1ControllerValue) = 0;

            // TODO: cleanup the interface. The velrelase and
            // velocityAttenuation parameters are perhaps too gig
            // specific.
            /**
             * Trigger the amplitude envelope generator.
             */
            virtual void TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;

            /**
             * Get current value of EG2 controller.
             */
            virtual double GetEG2ControllerValue(uint8_t MIDIKeyVelocity) = 0;

            /**
             * Calculate influence of EG2 controller on EG2's parameters.
             */
            virtual EGInfo CalculateEG2ControllerInfluence(double eg2ControllerValue) = 0;

            virtual float CalculateCutoffBase(uint8_t MIDIKeyVelocity) = 0;
            virtual float CalculateFinalCutoff(float cutoffBase) = 0;

            virtual void InitLFO1() = 0;
            virtual void InitLFO2() = 0;
            virtual void InitLFO3() = 0;

            virtual uint8_t GetVCFCutoffCtrl() = 0;
            virtual uint8_t GetVCFResonanceCtrl() = 0;
            virtual uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) = 0;

            virtual void    GetFirstEventOnKey(uint8_t MIDIKey, RTList<Event>::Iterator& itEvent) = 0;
            virtual void    ProcessCCEvent(RTList<Event>::Iterator& itEvent) = 0;
            virtual void    ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) = 0;
            virtual double  GetVelocityRelease(uint8_t MIDIKeyVelocity) = 0;

            virtual unsigned long GetNoteOnTime(int MIDIKey) = 0;
    };
} // namespace LinuxSampler

#endif  /* __LS_ABSTRACTVOICE_H__ */
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005-2008 Christian Schoenebeck *
7	* Copyright (C) 2009-2010 Christian Schoenebeck and Grigor Iliev *
8	* *
9	* This program is free software; you can redistribute it and/or modify *
10	* it under the terms of the GNU General Public License as published by *
11	* the Free Software Foundation; either version 2 of the License, or *
12	* (at your option) any later version. *
13	* *
14	* This program is distributed in the hope that it will be useful, *
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
17	* GNU General Public License for more details. *
18	* *
19	* You should have received a copy of the GNU General Public License *
20	* along with this program; if not, write to the Free Software *
21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
22	* MA 02111-1307 USA *
23	***************************************************************************/
24
25	#ifndef __LS_ABSTRACTVOICE_H__
26	#define __LS_ABSTRACTVOICE_H__
27
28	#include "Voice.h"
29
30	#include "../../common/global_private.h"
31	#include "../AbstractEngineChannel.h"
32	#include "../common/LFOBase.h"
33	#include "../EngineBase.h"
34	#include "EG.h"
35	#include "../gig/EGADSR.h"
36	#include "../gig/EGDecay.h"
37	#include "../gig/SmoothVolume.h"
38	#include "../gig/Synthesizer.h"
39	#include "../gig/Profiler.h"
40
41	// include the appropriate (unsigned) triangle LFO implementation
42	#if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
43	# include "../common/LFOTriangleIntMath.h"
44	#elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
45	# include "../common/LFOTriangleIntAbsMath.h"
46	#elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
47	# include "../common/LFOTriangleDiHarmonic.h"
48	#else
49	# error "Unknown or no (unsigned) triangle LFO implementation selected!"
50	#endif
51
52	// include the appropriate (signed) triangle LFO implementation
53	#if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
54	# include "../common/LFOTriangleIntMath.h"
55	#elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
56	# include "../common/LFOTriangleIntAbsMath.h"
57	#elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
58	# include "../common/LFOTriangleDiHarmonic.h"
59	#else
60	# error "Unknown or no (signed) triangle LFO implementation selected!"
61	#endif
62
63	namespace LinuxSampler {
64
65	#if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
66	typedef LFOTriangleIntMath<range_unsigned> LFOUnsigned;
67	#elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
68	typedef LFOTriangleIntAbsMath<range_unsigned> LFOUnsigned;
69	#elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
70	typedef LFOTriangleDiHarmonic<range_unsigned> LFOUnsigned;
71	#endif
72
73	#if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
74	typedef LFOTriangleIntMath<range_signed> LFOSigned;
75	#elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
76	typedef LFOTriangleIntAbsMath<range_signed> LFOSigned;
77	#elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
78	typedef LFOTriangleDiHarmonic<range_signed> LFOSigned;
79	#endif
80
81	class AbstractVoice : public Voice {
82	public:
83	type_t Type; ///< Voice Type
84	int MIDIKey; ///< MIDI key number of the key that triggered the voice
85	uint KeyGroup;
86
87	AbstractVoice();
88	virtual ~AbstractVoice();
89
90	inline bool IsActive() { return PlaybackState; }
91	inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
92
93	virtual void Reset();
94
95	virtual int Trigger (
96	AbstractEngineChannel* pEngineChannel,
97	Pool<Event>::Iterator& itNoteOnEvent,
98	int PitchBend,
99	type_t VoiceType,
100	int iKeyGroup
101	);
102
103	virtual void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
104
105	void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
106	void processPitchEvent(RTList<Event>::Iterator& itEvent);
107	void processResonanceEvent(RTList<Event>::Iterator& itEvent);
108	void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
109	void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
110	void Kill(Pool<Event>::Iterator& itKillEvent);
111
112	bool Orphan; ///< true if this voice is playing a sample from an instrument that is unloaded. When the voice dies, the sample (and dimension region) will be handed back to the instrument resource manager.
113	playback_state_t PlaybackState; ///< When a sample will be triggered, it will be first played from RAM cache and after a couple of sample points it will switch to disk streaming and at the end of a disk stream we have to add null samples, so the interpolator can do it's work correctly
114	Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
115
116	template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
117
118	protected:
119	SampleInfo SmplInfo;
120	RegionInfo RgnInfo;
121	InstrumentInfo InstrInfo;
122	AbstractEngineChannel* pEngineChannel;
123
124	double Pos; ///< Current playback position in sample
125	PitchInfo Pitch;
126	float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
127	float VolumeLeft; ///< Left channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
128	float VolumeRight; ///< Right channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
129	gig::SmoothVolume CrossfadeSmoother; ///< Crossfade volume, updated by crossfade CC events
130	gig::SmoothVolume VolumeSmoother; ///< Volume, updated by CC 7 (volume) events
131	gig::SmoothVolume PanLeftSmoother; ///< Left channel volume, updated by CC 10 (pan) events
132	gig::SmoothVolume PanRightSmoother; ///< Right channel volume, updated by CC 10 (pan) events
133	bool DiskVoice; ///< If the sample is very short it completely fits into the RAM cache and doesn't need to be streamed from disk, in that case this flag is set to false
134	bool RAMLoop; ///< If this voice has a loop defined which completely fits into the cached RAM part of the sample, in this case we handle the looping within the voice class, else if the loop is located in the disk stream part, we let the disk stream handle the looping
135	unsigned long MaxRAMPos; ///< The upper allowed limit (not actually the end) in the RAM sample cache, after that point it's not safe to chase the interpolator another time over over the current cache position, instead we switch to disk then.
136	uint Delay; ///< Number of sample points the rendering process of this voice should be delayed (jitter correction), will be set to 0 after the first audio fragment cycle
137	EG* pEG1; ///< Envelope Generator 1 (Amplification)
138	gig::EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency) TODO: use common EG instead of gig
139	gig::EGDecay EG3; ///< Envelope Generator 3 (Pitch) TODO: use common EG instead?
140	midi_ctrl VCFCutoffCtrl;
141	midi_ctrl VCFResonanceCtrl;
142	LFOUnsigned* pLFO1; ///< Low Frequency Oscillator 1 (Amplification)
143	LFOUnsigned* pLFO2; ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
144	LFOSigned* pLFO3; ///< Low Frequency Oscillator 3 (Pitch)
145	bool bLFO1Enabled; ///< Should we use the Amplitude LFO for this voice?
146	bool bLFO2Enabled; ///< Should we use the Filter Cutoff LFO for this voice?
147	bool bLFO3Enabled; ///< Should we use the Pitch LFO for this voice?
148	Pool<Event>::Iterator itTriggerEvent; ///< First event on the key's list the voice should process (only needed for the first audio fragment in which voice was triggered, after that it will be set to NULL).
149	Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
150	int SynthesisMode;
151	float fFinalCutoff;
152	float fFinalResonance;
153	gig::SynthesisParam finalSynthesisParameters;
154	gig::Loop loop;
155
156
157	virtual AbstractEngine* GetEngine() = 0;
158	virtual SampleInfo GetSampleInfo() = 0;
159	virtual RegionInfo GetRegionInfo() = 0;
160	virtual InstrumentInfo GetInstrumentInfo() = 0;
161
162	/**
163	* Gets the sample cache size in bytes.
164	*/
165	virtual unsigned long GetSampleCacheSize() = 0;
166
167	/**
168	* Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
169	* All involved parameters (VelocityResponseCurve, VelocityResponseDepth
170	* and VelocityResponseCurveScaling) involved are taken into account to
171	* calculate the amplitude factor. Use this method when a key was
172	* triggered to get the volume with which the sample should be played
173	* back.
174	*
175	* @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
176	* @returns amplitude factor (between 0.0 and 1.0)
177	*/
178	virtual double GetVelocityAttenuation(uint8_t MIDIKeyVelocity) = 0;
179
180	virtual double GetSampleAttenuation() = 0;
181
182	virtual double CalculateVolume(double velocityAttenuation);
183
184	/**
185	* Get starting crossfade volume level
186	*/
187	virtual double CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) = 0;
188
189	virtual int OrderNewStream() = 0;
190
191	virtual PitchInfo CalculatePitchInfo(int PitchBend);
192
193	// TODO: cleanup the interface. The following two methods
194	// are maybe not neccessary after the TriggerEG1 method
195	// was added.
196
197	/**
198	* Get current value of EG1 controller.
199	*/
200	virtual double GetEG1ControllerValue(uint8_t MIDIKeyVelocity) = 0;
201
202	/**
203	* Calculate influence of EG1 controller on EG1's parameters.
204	*/
205	virtual EGInfo CalculateEG1ControllerInfluence(double eg1ControllerValue) = 0;
206
207	// TODO: cleanup the interface. The velrelase and
208	// velocityAttenuation parameters are perhaps too gig
209	// specific.
210	/**
211	* Trigger the amplitude envelope generator.
212	*/
213	virtual void TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;
214
215	/**
216	* Get current value of EG2 controller.
217	*/
218	virtual double GetEG2ControllerValue(uint8_t MIDIKeyVelocity) = 0;
219
220	/**
221	* Calculate influence of EG2 controller on EG2's parameters.
222	*/
223	virtual EGInfo CalculateEG2ControllerInfluence(double eg2ControllerValue) = 0;
224
225	virtual float CalculateCutoffBase(uint8_t MIDIKeyVelocity) = 0;
226	virtual float CalculateFinalCutoff(float cutoffBase) = 0;
227
228	virtual void InitLFO1() = 0;
229	virtual void InitLFO2() = 0;
230	virtual void InitLFO3() = 0;
231
232	virtual uint8_t GetVCFCutoffCtrl() = 0;
233	virtual uint8_t GetVCFResonanceCtrl() = 0;
234	virtual uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) = 0;
235
236	virtual void GetFirstEventOnKey(uint8_t MIDIKey, RTList<Event>::Iterator& itEvent) = 0;
237	virtual void ProcessCCEvent(RTList<Event>::Iterator& itEvent) = 0;
238	virtual void ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) = 0;
239	virtual double GetVelocityRelease(uint8_t MIDIKeyVelocity) = 0;
240
241	virtual unsigned long GetNoteOnTime(int MIDIKey) = 0;
242	};
243	} // namespace LinuxSampler
244
245	#endif /* __LS_ABSTRACTVOICE_H__ */