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);

            virtual float GetReleaseTriggerAttenuation(float noteLength);

            /**
             * 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	iliev	2015	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6	persson	2055	* Copyright (C) 2005-2008 Christian Schoenebeck *
7			* Copyright (C) 2009-2010 Christian Schoenebeck and Grigor Iliev *
8	iliev	2015	* *
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	persson	2055	#include "EG.h"
35	iliev	2015	#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	persson	2055	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	iliev	2015	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	persson	2061	virtual float GetReleaseTriggerAttenuation(float noteLength);
185
186	iliev	2015	/**
187			* Get starting crossfade volume level
188			*/
189			virtual double CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) = 0;
190
191			virtual int OrderNewStream() = 0;
192
193			virtual PitchInfo CalculatePitchInfo(int PitchBend);
194
195	persson	2055	// TODO: cleanup the interface. The following two methods
196			// are maybe not neccessary after the TriggerEG1 method
197			// was added.
198
199	iliev	2015	/**
200			* Get current value of EG1 controller.
201			*/
202			virtual double GetEG1ControllerValue(uint8_t MIDIKeyVelocity) = 0;
203
204			/**
205			* Calculate influence of EG1 controller on EG1's parameters.
206			*/
207			virtual EGInfo CalculateEG1ControllerInfluence(double eg1ControllerValue) = 0;
208
209	persson	2055	// TODO: cleanup the interface. The velrelase and
210			// velocityAttenuation parameters are perhaps too gig
211			// specific.
212	iliev	2015	/**
213	persson	2055	* Trigger the amplitude envelope generator.
214			*/
215			virtual void TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;
216
217			/**
218	iliev	2015	* Get current value of EG2 controller.
219			*/
220			virtual double GetEG2ControllerValue(uint8_t MIDIKeyVelocity) = 0;
221
222			/**
223			* Calculate influence of EG2 controller on EG2's parameters.
224			*/
225			virtual EGInfo CalculateEG2ControllerInfluence(double eg2ControllerValue) = 0;
226
227			virtual float CalculateCutoffBase(uint8_t MIDIKeyVelocity) = 0;
228			virtual float CalculateFinalCutoff(float cutoffBase) = 0;
229
230			virtual void InitLFO1() = 0;
231			virtual void InitLFO2() = 0;
232			virtual void InitLFO3() = 0;
233
234			virtual uint8_t GetVCFCutoffCtrl() = 0;
235			virtual uint8_t GetVCFResonanceCtrl() = 0;
236			virtual uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) = 0;
237
238			virtual void GetFirstEventOnKey(uint8_t MIDIKey, RTList<Event>::Iterator& itEvent) = 0;
239			virtual void ProcessCCEvent(RTList<Event>::Iterator& itEvent) = 0;
240			virtual void ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) = 0;
241			virtual double GetVelocityRelease(uint8_t MIDIKeyVelocity) = 0;
242
243			virtual unsigned long GetNoteOnTime(int MIDIKey) = 0;
244			};
245			} // namespace LinuxSampler
246
247			#endif /* __LS_ABSTRACTVOICE_H__ */