/[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 2219 - (show annotations) (download) (as text)
Thu Jul 28 12:35:49 2011 UTC (8 years, 3 months ago) by iliev
File MIME type: text/x-c++hdr
File size: 16077 byte(s)
* sfz engine: implemented opcodes lfoN_delay,
  lfoN_freq, lfoN_pan, lfoN_cutoff, lfoN_resonance

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-2011 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 #include "SignalUnitRack.h"
41
42 // include the appropriate (unsigned) triangle LFO implementation
43 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
44 # include "../common/LFOTriangleIntMath.h"
45 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
46 # include "../common/LFOTriangleIntAbsMath.h"
47 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
48 # include "../common/LFOTriangleDiHarmonic.h"
49 #else
50 # error "Unknown or no (unsigned) triangle LFO implementation selected!"
51 #endif
52
53 // include the appropriate (signed) triangle LFO implementation
54 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
55 # include "../common/LFOTriangleIntMath.h"
56 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
57 # include "../common/LFOTriangleIntAbsMath.h"
58 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
59 # include "../common/LFOTriangleDiHarmonic.h"
60 #else
61 # error "Unknown or no (signed) triangle LFO implementation selected!"
62 #endif
63
64 namespace LinuxSampler {
65
66 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
67 typedef LFOTriangleIntMath<range_unsigned> LFOUnsigned;
68 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
69 typedef LFOTriangleIntAbsMath<range_unsigned> LFOUnsigned;
70 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
71 typedef LFOTriangleDiHarmonic<range_unsigned> LFOUnsigned;
72 #endif
73
74 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
75 typedef LFOTriangleIntMath<range_signed> LFOSigned;
76 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
77 typedef LFOTriangleIntAbsMath<range_signed> LFOSigned;
78 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
79 typedef LFOTriangleDiHarmonic<range_signed> LFOSigned;
80 #endif
81
82 class AbstractVoice : public Voice {
83 public:
84 type_t Type; ///< Voice Type (bit field, a voice may have several types)
85 int MIDIKey; ///< MIDI key number of the key that triggered the voice
86 uint8_t MIDIVelocity; ///< MIDI velocity of the key that triggered the voice
87 uint8_t MIDIPan; ///< the current MIDI pan value
88
89 SignalUnitRack* const pSignalUnitRack;
90
91 AbstractVoice(SignalUnitRack* pRack);
92 virtual ~AbstractVoice();
93
94 inline bool IsActive() { return PlaybackState; }
95 inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
96
97 virtual void Reset();
98
99 virtual int Trigger (
100 AbstractEngineChannel* pEngineChannel,
101 Pool<Event>::Iterator& itNoteOnEvent,
102 int PitchBend,
103 type_t VoiceType,
104 int iKeyGroup
105 );
106
107 virtual void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
108
109 uint GetSampleRate() { return GetEngine()->SampleRate; }
110
111 void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
112 void processPitchEvent(RTList<Event>::Iterator& itEvent);
113 void processResonanceEvent(RTList<Event>::Iterator& itEvent);
114 void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
115 void processGroupEvents(RTList<Event>::Iterator& itEvent, uint End);
116 void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
117 void Kill(Pool<Event>::Iterator& itKillEvent);
118
119 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.
120 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
121 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
122
123 template<class TV, class TRR, class TR, class TD, class TIM, class TI> friend class EngineBase;
124
125 protected:
126 SampleInfo SmplInfo;
127 RegionInfo RgnInfo;
128 InstrumentInfo InstrInfo;
129 AbstractEngineChannel* pEngineChannel;
130
131 double Pos; ///< Current playback position in sample
132 PitchInfo Pitch;
133 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
134 float VolumeLeft; ///< Left channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
135 float VolumeRight; ///< Right channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
136 gig::SmoothVolume CrossfadeSmoother; ///< Crossfade volume, updated by crossfade CC events
137 gig::SmoothVolume VolumeSmoother; ///< Volume, updated by CC 7 (volume) events
138 gig::SmoothVolume PanLeftSmoother; ///< Left channel volume, updated by CC 10 (pan) events
139 gig::SmoothVolume PanRightSmoother; ///< Right channel volume, updated by CC 10 (pan) events
140 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
141 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
142 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.
143 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
144 EG* pEG1; ///< Envelope Generator 1 (Amplification)
145 EG* pEG2; ///< Envelope Generator 2 (Filter cutoff frequency)
146 gig::EGDecay EG3; ///< Envelope Generator 3 (Pitch) TODO: use common EG instead?
147 midi_ctrl VCFCutoffCtrl;
148 midi_ctrl VCFResonanceCtrl;
149 LFOUnsigned* pLFO1; ///< Low Frequency Oscillator 1 (Amplification)
150 LFOUnsigned* pLFO2; ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
151 LFOSigned* pLFO3; ///< Low Frequency Oscillator 3 (Pitch)
152 bool bLFO1Enabled; ///< Should we use the Amplitude LFO for this voice?
153 bool bLFO2Enabled; ///< Should we use the Filter Cutoff LFO for this voice?
154 bool bLFO3Enabled; ///< Should we use the Pitch LFO for this voice?
155 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).
156 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
157 int SynthesisMode;
158 float fFinalCutoff;
159 float fFinalResonance;
160 gig::SynthesisParam finalSynthesisParameters;
161 gig::Loop loop;
162 RTList<Event>* pGroupEvents; ///< Events directed to an exclusive group
163
164 virtual AbstractEngine* GetEngine() = 0;
165 virtual SampleInfo GetSampleInfo() = 0;
166 virtual RegionInfo GetRegionInfo() = 0;
167 virtual InstrumentInfo GetInstrumentInfo() = 0;
168
169 /**
170 * Most of the important members of the voice are set when the voice
171 * is triggered (like pEngineChannel, pRegion, pSample, etc).
172 * This method is called after these members are set and before
173 * the voice is actually triggered.
174 * Override this method if you need to do some additional
175 * initialization which depends on these members before the voice
176 * is triggered.
177 */
178 virtual void AboutToTrigger() { }
179
180 virtual bool EG1Finished();
181
182 /**
183 * Gets the sample cache size in bytes.
184 */
185 virtual unsigned long GetSampleCacheSize() = 0;
186
187 /**
188 * Because in most cases we cache part of the sample in RAM, if the
189 * offset is too big (will extend beyond the RAM cache if the cache contains
190 * the beginning of the sample) we should cache in the RAM buffer not the
191 * beginning of the sample but a part that starts from the sample offset point.
192 * In that case the current sample position should start from zero (Pos).
193 * When the offset fits into RAM buffer or the whole sample is cached
194 * in RAM, Pos should contain the actual offset.
195 * We don't trim the sample because it might have a defined
196 * loop start point before the start point of the playback.
197 */
198 virtual void SetSampleStartOffset();
199
200 /**
201 * Returns the correct amplitude factor for the given \a MIDIKeyVelocity.
202 * All involved parameters (VelocityResponseCurve, VelocityResponseDepth
203 * and VelocityResponseCurveScaling) involved are taken into account to
204 * calculate the amplitude factor. Use this method when a key was
205 * triggered to get the volume with which the sample should be played
206 * back.
207 *
208 * @param MIDIKeyVelocity MIDI velocity value of the triggered key (between 0 and 127)
209 * @returns amplitude factor (between 0.0 and 1.0)
210 */
211 virtual double GetVelocityAttenuation(uint8_t MIDIKeyVelocity) = 0;
212
213 virtual double GetSampleAttenuation() = 0;
214
215 virtual double CalculateVolume(double velocityAttenuation);
216
217 virtual float GetReleaseTriggerAttenuation(float noteLength);
218
219 /**
220 * Get starting crossfade volume level
221 */
222 virtual double CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) = 0;
223
224 virtual MidiKeyBase* GetMidiKeyInfo(int MIDIKey) = 0;
225
226 virtual int OrderNewStream() = 0;
227
228 virtual PitchInfo CalculatePitchInfo(int PitchBend);
229
230 // TODO: cleanup the interface. The following two methods
231 // are maybe not neccessary after the TriggerEG1 method
232 // was added.
233
234 /**
235 * Get current value of EG1 controller.
236 */
237 virtual double GetEG1ControllerValue(uint8_t MIDIKeyVelocity) = 0;
238
239 /**
240 * Calculate influence of EG1 controller on EG1's parameters.
241 */
242 virtual EGInfo CalculateEG1ControllerInfluence(double eg1ControllerValue) = 0;
243
244 // TODO: cleanup the interface. The velrelase and
245 // velocityAttenuation parameters are perhaps too gig
246 // specific.
247 /**
248 * Trigger the amplitude envelope generator.
249 */
250 virtual void TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;
251
252 /**
253 * Get current value of EG2 controller.
254 */
255 virtual double GetEG2ControllerValue(uint8_t MIDIKeyVelocity) = 0;
256
257 /**
258 * Calculate influence of EG2 controller on EG2's parameters.
259 */
260 virtual EGInfo CalculateEG2ControllerInfluence(double eg2ControllerValue) = 0;
261
262 virtual void TriggerEG2(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) = 0;
263
264 virtual float CalculateCutoffBase(uint8_t MIDIKeyVelocity) = 0;
265 virtual float CalculateFinalCutoff(float cutoffBase) = 0;
266
267 virtual void InitLFO1() = 0;
268 virtual void InitLFO2() = 0;
269 virtual void InitLFO3() = 0;
270
271 virtual uint8_t GetVCFCutoffCtrl() = 0;
272 virtual uint8_t GetVCFResonanceCtrl() = 0;
273 virtual uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) = 0;
274
275 virtual void GetFirstEventOnKey(uint8_t MIDIKey, RTList<Event>::Iterator& itEvent) = 0;
276 virtual void ProcessCCEvent(RTList<Event>::Iterator& itEvent) = 0;
277 virtual void ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) = 0;
278 virtual double GetVelocityRelease(uint8_t MIDIKeyVelocity) = 0;
279
280 virtual unsigned long GetNoteOnTime(int MIDIKey) = 0;
281
282 virtual void ProcessGroupEvent(RTList<Event>::Iterator& itEvent) = 0;
283 void EnterReleaseStage();
284 };
285 } // namespace LinuxSampler
286
287 #endif /* __LS_ABSTRACTVOICE_H__ */

  ViewVC Help
Powered by ViewVC