/[svn]/linuxsampler/trunk/src/engines/gig/Voice.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/gig/Voice.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 770 - (show annotations) (download) (as text)
Sun Sep 11 15:56:29 2005 UTC (18 years, 6 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 13068 byte(s)
* synthesis core optimizations

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 Christian Schoenebeck *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LS_GIG_VOICE_H__
25 #define __LS_GIG_VOICE_H__
26
27 #include "../../common/global.h"
28
29 #include <gig.h>
30
31 #include "../../common/RTMath.h"
32 #include "../../common/RingBuffer.h"
33 #include "../../common/Pool.h"
34 #include "../../drivers/audio/AudioOutputDevice.h"
35 #include "../common/BiquadFilter.h"
36 #include "Engine.h"
37 #include "EngineChannel.h"
38 #include "Stream.h"
39 #include "DiskThread.h"
40 #include "EGADSR.h"
41 #include "EGDecay.h"
42 #include "Filter.h"
43 #include "../common/LFOBase.h"
44 #include "SynthesisParam.h"
45
46 // include the appropriate (unsigned) triangle LFO implementation
47 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
48 # include "../common/LFOTriangleIntMath.h"
49 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
50 # include "../common/LFOTriangleIntAbsMath.h"
51 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
52 # include "../common/LFOTriangleDiHarmonic.h"
53 #else
54 # error "Unknown or no (unsigned) triangle LFO implementation selected!"
55 #endif
56
57 // include the appropriate (signed) triangle LFO implementation
58 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
59 # include "../common/LFOTriangleIntMath.h"
60 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
61 # include "../common/LFOTriangleIntAbsMath.h"
62 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
63 # include "../common/LFOTriangleDiHarmonic.h"
64 #else
65 # error "Unknown or no (signed) triangle LFO implementation selected!"
66 #endif
67
68 namespace LinuxSampler { namespace gig {
69
70 class Engine;
71
72 /// Reflects a MIDI controller
73 struct midi_ctrl {
74 uint8_t controller; ///< MIDI control change controller number
75 uint8_t value; ///< Current MIDI controller value
76 float fvalue; ///< Transformed / effective value (e.g. volume level or filter cutoff frequency)
77 };
78
79 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
80 typedef LFOTriangleIntMath<range_unsigned> LFOUnsigned;
81 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
82 typedef LFOTriangleIntAbsMath<range_unsigned> LFOUnsigned;
83 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
84 typedef LFOTriangleDiHarmonic<range_unsigned> LFOUnsigned;
85 #endif
86
87 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
88 typedef LFOTriangleIntMath<range_signed> LFOSigned;
89 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
90 typedef LFOTriangleIntAbsMath<range_signed> LFOSigned;
91 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
92 typedef LFOTriangleDiHarmonic<range_signed> LFOSigned;
93 #endif
94
95 /** Gig Voice
96 *
97 * Renders a voice for the Gigasampler format.
98 */
99 class Voice {
100 public:
101 // Types
102 enum type_t {
103 type_normal,
104 type_release_trigger_required, ///< If the key of this voice will be released, it causes a release triggered voice to be spawned
105 type_release_trigger ///< Release triggered voice which cannot be killed by releasing its key
106 };
107
108 // Attributes
109 type_t Type; ///< Voice Type
110 int MIDIKey; ///< MIDI key number of the key that triggered the voice
111 uint KeyGroup;
112 DiskThread* pDiskThread; ///< Pointer to the disk thread, to be able to order a disk stream and later to delete the stream again
113
114 // Methods
115 Voice();
116 virtual ~Voice();
117 void Kill(Pool<Event>::Iterator& itKillEvent);
118 void Render(uint Samples);
119 void Reset();
120 void SetOutput(AudioOutputDevice* pAudioOutputDevice);
121 void SetEngine(Engine* pEngine);
122 int Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup);
123 inline bool IsActive() { return PlaybackState; }
124 inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
125 //private:
126 // Types
127 enum playback_state_t {
128 playback_state_end = 0,
129 playback_state_init = 1,
130 playback_state_ram = 2,
131 playback_state_disk = 3
132 };
133
134 // Attributes
135 EngineChannel* pEngineChannel;
136 Engine* pEngine; ///< Pointer to the sampler engine, to be able to access the event lists.
137 float Volume; ///< Volume level of the voice
138 float PanLeft;
139 float PanRight;
140 float CrossfadeVolume; ///< Current attenuation level caused by a crossfade (only if a crossfade is defined of course)
141 //double Pos; ///< Current playback position in sample
142 float PitchBase; ///< Basic pitch depth, stays the same for the whole life time of the voice
143 float PitchBend; ///< Current pitch value of the pitchbend wheel
144 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
145 ::gig::Sample* pSample; ///< Pointer to the sample to be played back
146 ::gig::DimensionRegion* pDimRgn; ///< Pointer to the articulation information of current dimension region of this voice
147 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
148 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
149 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
150 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
151 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.
152 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
153 //uint LoopCyclesLeft; ///< In case there is a RAMLoop and it's not an endless loop; reflects number of loop cycles left to be passed
154 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
155 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
156 EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
157 EGDecay EG3; ///< Envelope Generator 3 (Pitch)
158 midi_ctrl VCFCutoffCtrl;
159 midi_ctrl VCFResonanceCtrl;
160 static const float FILTER_CUTOFF_COEFF;
161 LFOUnsigned* pLFO1; ///< Low Frequency Oscillator 1 (Amplification)
162 LFOUnsigned* pLFO2; ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
163 LFOSigned* pLFO3; ///< Low Frequency Oscillator 3 (Pitch)
164 bool bLFO1Enabled; ///< Should we use the Amplitude LFO for this voice?
165 bool bLFO2Enabled; ///< Should we use the Filter Cutoff LFO for this voice?
166 bool bLFO3Enabled; ///< Should we use the Pitch LFO for this voice?
167 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).
168 //public: // FIXME: just made public for debugging (sanity check in Engine::RenderAudio()), should be changed to private before the final release
169 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
170 //private:
171 int SynthesisMode;
172 float fFinalVolume;
173 float fFinalCutoff;
174 float fFinalResonance;
175 SynthesisParam finalSynthesisParameters;
176 Loop loop;
177
178 // Static Methods
179 static float CalculateFilterCutoffCoeff();
180
181 // Methods
182 void KillImmediately();
183 void ProcessEvents(uint Samples);
184 void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
185 void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
186 void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
187 void processPitchEvent(RTList<Event>::Iterator& itEvent);
188 void processCrossFadeEvent(RTList<Event>::Iterator& itEvent);
189 void processCutoffEvent(RTList<Event>::Iterator& itEvent);
190 void processResonanceEvent(RTList<Event>::Iterator& itEvent);
191
192 inline float CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
193 float att = (!pDimRgn->Crossfade.out_end) ? CrossfadeControllerValue / 127.0f /* 0,0,0,0 means no crossfade defined */
194 : (CrossfadeControllerValue < pDimRgn->Crossfade.in_end) ?
195 ((CrossfadeControllerValue <= pDimRgn->Crossfade.in_start) ? 0.0f
196 : float(CrossfadeControllerValue - pDimRgn->Crossfade.in_start) / float(pDimRgn->Crossfade.in_end - pDimRgn->Crossfade.in_start))
197 : (CrossfadeControllerValue <= pDimRgn->Crossfade.out_start) ? 1.0f
198 : (CrossfadeControllerValue < pDimRgn->Crossfade.out_end) ? float(pDimRgn->Crossfade.out_end - CrossfadeControllerValue) / float(pDimRgn->Crossfade.out_end - pDimRgn->Crossfade.out_start)
199 : 0.0f;
200 return pDimRgn->InvertAttenuationController ? 1 - att : att;
201 }
202
203 inline float Constrain(float ValueToCheck, float Min, float Max) {
204 if (ValueToCheck > Max) ValueToCheck = Max;
205 else if (ValueToCheck < Min) ValueToCheck = Min;
206 return ValueToCheck;
207 }
208 };
209
210 }} // namespace LinuxSampler::gig
211
212 #endif // __LS_GIG_VOICE_H__

  ViewVC Help
Powered by ViewVC