/[svn]/linuxsampler/trunk/src/engines/common/AbstractVoice.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/AbstractVoice.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2115 - (show annotations) (download) (as text)
Thu Aug 12 15:36:15 2010 UTC (13 years, 7 months ago) by persson
File MIME type: text/x-c++hdr
File size: 14148 byte(s)
* sfz engine: added support for controller triggered regions
  (on_locc/on_hicc)
* sfz engine: added support for loop_mode=one_shot

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 (bit field, a voice may have several types)
84 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 void processGroupEvents(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 RTList<Event>* pGroupEvents; ///< Events directed to an exclusive group
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 virtual float GetReleaseTriggerAttenuation(float noteLength);
185
186 /**
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 // TODO: cleanup the interface. The following two methods
196 // are maybe not neccessary after the TriggerEG1 method
197 // was added.
198
199 /**
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 // TODO: cleanup the interface. The velrelase and
210 // velocityAttenuation parameters are perhaps too gig
211 // specific.
212 /**
213 * 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 * 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 virtual void ProcessGroupEvent(RTList<Event>::Iterator& itEvent) = 0;
246 void EnterReleaseStage();
247 };
248 } // namespace LinuxSampler
249
250 #endif /* __LS_ABSTRACTVOICE_H__ */

  ViewVC Help
Powered by ViewVC