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 (bit field, a voice may have several types)
            int          MIDIKey;      ///< MIDI key number of the key that triggered the voice

            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 processGroupEvents(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;
            RTList<Event>*              pGroupEvents;        ///< Events directed to an exclusive group

            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 MidiKeyBase* GetMidiKeyInfo(int MIDIKey) = 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;

            virtual void    ProcessGroupEvent(RTList<Event>::Iterator& itEvent) = 0;
            void            EnterReleaseStage();
    };
} // 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	persson	2114	#define __LS_ABSTRACTVOICE_H__
27	iliev	2015
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	persson	2115	type_t Type; ///< Voice Type (bit field, a voice may have several types)
84	iliev	2015	int MIDIKey; ///< MIDI key number of the key that triggered the voice
85
86			AbstractVoice();
87			virtual ~AbstractVoice();
88
89			inline bool IsActive() { return PlaybackState; }
90			inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
91
92			virtual void Reset();
93
94			virtual int Trigger (
95			AbstractEngineChannel* pEngineChannel,
96			Pool<Event>::Iterator& itNoteOnEvent,
97			int PitchBend,
98			type_t VoiceType,
99			int iKeyGroup
100			);
101
102			virtual void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
103
104			void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
105			void processPitchEvent(RTList<Event>::Iterator& itEvent);
106			void processResonanceEvent(RTList<Event>::Iterator& itEvent);
107			void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
108	persson	2114	void processGroupEvents(RTList<Event>::Iterator& itEvent, uint End);
109	iliev	2015	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	persson	2114	RTList<Event>* pGroupEvents; ///< Events directed to an exclusive group
156	iliev	2015
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	schoenebeck	2121	virtual MidiKeyBase* GetMidiKeyInfo(int MIDIKey) = 0;
192
193	iliev	2015	virtual int OrderNewStream() = 0;
194
195			virtual PitchInfo CalculatePitchInfo(int PitchBend);
196
197	persson	2055	// TODO: cleanup the interface. The following two methods
198			// are maybe not neccessary after the TriggerEG1 method
199			// was added.
200
201	iliev	2015	/**
202			* Get current value of EG1 controller.
203			*/
204			virtual double GetEG1ControllerValue(uint8_t MIDIKeyVelocity) = 0;
205
206			/**
207			* Calculate influence of EG1 controller on EG1's parameters.
208			*/
209			virtual EGInfo CalculateEG1ControllerInfluence(double eg1ControllerValue) = 0;
210
211	persson	2055	// TODO: cleanup the interface. The velrelase and
212			// velocityAttenuation parameters are perhaps too gig
213			// specific.
214	iliev	2015	/**
215	persson	2055	* Trigger the amplitude envelope generator.
216			*/
217			virtual void TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;
218
219			/**
220	iliev	2015	* Get current value of EG2 controller.
221			*/
222			virtual double GetEG2ControllerValue(uint8_t MIDIKeyVelocity) = 0;
223
224			/**
225			* Calculate influence of EG2 controller on EG2's parameters.
226			*/
227			virtual EGInfo CalculateEG2ControllerInfluence(double eg2ControllerValue) = 0;
228
229			virtual float CalculateCutoffBase(uint8_t MIDIKeyVelocity) = 0;
230			virtual float CalculateFinalCutoff(float cutoffBase) = 0;
231
232			virtual void InitLFO1() = 0;
233			virtual void InitLFO2() = 0;
234			virtual void InitLFO3() = 0;
235
236			virtual uint8_t GetVCFCutoffCtrl() = 0;
237			virtual uint8_t GetVCFResonanceCtrl() = 0;
238			virtual uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) = 0;
239
240			virtual void GetFirstEventOnKey(uint8_t MIDIKey, RTList<Event>::Iterator& itEvent) = 0;
241			virtual void ProcessCCEvent(RTList<Event>::Iterator& itEvent) = 0;
242			virtual void ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) = 0;
243			virtual double GetVelocityRelease(uint8_t MIDIKeyVelocity) = 0;
244
245			virtual unsigned long GetNoteOnTime(int MIDIKey) = 0;
246	persson	2114
247			virtual void ProcessGroupEvent(RTList<Event>::Iterator& itEvent) = 0;
248			void EnterReleaseStage();
249	iliev	2015	};
250			} // namespace LinuxSampler
251
252	persson	2114	#endif /* __LS_ABSTRACTVOICE_H__ */