/[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 877 - (show annotations) (download) (as text)
Sun Jun 25 13:54:17 2006 UTC (17 years, 9 months ago) by persson
File MIME type: text/x-c++hdr
File size: 13331 byte(s)
* new filter implementation, which is more accurate and supports all
  filter types including bandreject and lowpass turbo

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005, 2006 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/Pool.h"
33 #include "../../drivers/audio/AudioOutputDevice.h"
34 #include "Engine.h"
35 #include "EngineChannel.h"
36 #include "Stream.h"
37 #include "DiskThread.h"
38 #include "EGADSR.h"
39 #include "EGDecay.h"
40 #include "Filter.h"
41 #include "../common/LFOBase.h"
42 #include "SynthesisParam.h"
43 #include "SmoothVolume.h"
44
45 // include the appropriate (unsigned) triangle LFO implementation
46 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
47 # include "../common/LFOTriangleIntMath.h"
48 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
49 # include "../common/LFOTriangleIntAbsMath.h"
50 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
51 # include "../common/LFOTriangleDiHarmonic.h"
52 #else
53 # error "Unknown or no (unsigned) triangle LFO implementation selected!"
54 #endif
55
56 // include the appropriate (signed) triangle LFO implementation
57 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
58 # include "../common/LFOTriangleIntMath.h"
59 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
60 # include "../common/LFOTriangleIntAbsMath.h"
61 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
62 # include "../common/LFOTriangleDiHarmonic.h"
63 #else
64 # error "Unknown or no (signed) triangle LFO implementation selected!"
65 #endif
66
67 namespace LinuxSampler { namespace gig {
68
69 class Engine;
70
71 /// Reflects a MIDI controller
72 struct midi_ctrl {
73 uint8_t controller; ///< MIDI control change controller number
74 uint8_t value; ///< Current MIDI controller value
75 float fvalue; ///< Transformed / effective value (e.g. volume level or filter cutoff frequency)
76 };
77
78 #if CONFIG_UNSIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
79 typedef LFOTriangleIntMath<range_unsigned> LFOUnsigned;
80 #elif CONFIG_UNSIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
81 typedef LFOTriangleIntAbsMath<range_unsigned> LFOUnsigned;
82 #elif CONFIG_UNSIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
83 typedef LFOTriangleDiHarmonic<range_unsigned> LFOUnsigned;
84 #endif
85
86 #if CONFIG_SIGNED_TRIANG_ALGO == INT_MATH_SOLUTION
87 typedef LFOTriangleIntMath<range_signed> LFOSigned;
88 #elif CONFIG_SIGNED_TRIANG_ALGO == INT_ABS_MATH_SOLUTION
89 typedef LFOTriangleIntAbsMath<range_signed> LFOSigned;
90 #elif CONFIG_SIGNED_TRIANG_ALGO == DI_HARMONIC_SOLUTION
91 typedef LFOTriangleDiHarmonic<range_signed> LFOSigned;
92 #endif
93
94 /** Gig Voice
95 *
96 * Renders a voice for the Gigasampler format.
97 */
98 class Voice {
99 public:
100 // Types
101 enum type_t {
102 type_normal,
103 type_release_trigger_required, ///< If the key of this voice will be released, it causes a release triggered voice to be spawned
104 type_release_trigger ///< Release triggered voice which cannot be killed by releasing its key
105 };
106
107 // Attributes
108 type_t Type; ///< Voice Type
109 int MIDIKey; ///< MIDI key number of the key that triggered the voice
110 uint KeyGroup;
111 DiskThread* pDiskThread; ///< Pointer to the disk thread, to be able to order a disk stream and later to delete the stream again
112
113 // Methods
114 Voice();
115 virtual ~Voice();
116 void Kill(Pool<Event>::Iterator& itKillEvent);
117 void Render(uint Samples);
118 void Reset();
119 void SetOutput(AudioOutputDevice* pAudioOutputDevice);
120 void SetEngine(Engine* pEngine);
121 int Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup);
122 inline bool IsActive() { return PlaybackState; }
123 inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
124 void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
125
126 //private:
127 // Types
128 enum playback_state_t {
129 playback_state_end = 0,
130 playback_state_init = 1,
131 playback_state_ram = 2,
132 playback_state_disk = 3
133 };
134
135 // Attributes
136 EngineChannel* pEngineChannel;
137 Engine* pEngine; ///< Pointer to the sampler engine, to be able to access the event lists.
138 float VolumeLeft; ///< Left channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
139 float VolumeRight; ///< Right channel volume. This factor is calculated when the voice is triggered and doesn't change after that.
140 SmoothVolume CrossfadeSmoother; ///< Crossfade volume, updated by crossfade CC events
141 SmoothVolume VolumeSmoother; ///< Volume, updated by CC 7 (volume) events
142 SmoothVolume PanLeftSmoother; ///< Left channel volume, updated by CC 10 (pan) events
143 SmoothVolume PanRightSmoother; ///< Right channel volume, updated by CC 10 (pan) events
144 double Pos; ///< Current playback position in sample
145 float PitchBase; ///< Basic pitch depth, stays the same for the whole life time of the voice
146 float PitchBend; ///< Current pitch value of the pitchbend wheel
147 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
148 ::gig::Sample* pSample; ///< Pointer to the sample to be played back
149 ::gig::DimensionRegion* pDimRgn; ///< Pointer to the articulation information of current dimension region of this voice
150 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
151 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
152 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
153 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
154 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.
155 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
156 //uint LoopCyclesLeft; ///< In case there is a RAMLoop and it's not an endless loop; reflects number of loop cycles left to be passed
157 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
158 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
159 EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
160 EGDecay EG3; ///< Envelope Generator 3 (Pitch)
161 midi_ctrl VCFCutoffCtrl;
162 midi_ctrl VCFResonanceCtrl;
163 LFOUnsigned* pLFO1; ///< Low Frequency Oscillator 1 (Amplification)
164 LFOUnsigned* pLFO2; ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
165 LFOSigned* pLFO3; ///< Low Frequency Oscillator 3 (Pitch)
166 bool bLFO1Enabled; ///< Should we use the Amplitude LFO for this voice?
167 bool bLFO2Enabled; ///< Should we use the Filter Cutoff LFO for this voice?
168 bool bLFO3Enabled; ///< Should we use the Pitch LFO for this voice?
169 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).
170 //public: // FIXME: just made public for debugging (sanity check in Engine::RenderAudio()), should be changed to private before the final release
171 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
172 //private:
173 int SynthesisMode;
174 float fFinalCutoff;
175 float fFinalResonance;
176 SynthesisParam finalSynthesisParameters;
177 Loop loop;
178
179 // Static Methods
180 static float CalculateFilterCutoffCoeff();
181
182 // Methods
183 void KillImmediately();
184 void ProcessEvents(uint Samples);
185 void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
186 void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
187 void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
188 void processPitchEvent(RTList<Event>::Iterator& itEvent);
189 void processCrossFadeEvent(RTList<Event>::Iterator& itEvent);
190 void processCutoffEvent(RTList<Event>::Iterator& itEvent);
191 void processResonanceEvent(RTList<Event>::Iterator& itEvent);
192
193 inline uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
194 uint8_t c = std::max(CrossfadeControllerValue, pDimRgn->AttenuationControllerThreshold);
195 c = (!pDimRgn->Crossfade.out_end) ? c /* 0,0,0,0 means no crossfade defined */
196 : (c < pDimRgn->Crossfade.in_end) ?
197 ((c <= pDimRgn->Crossfade.in_start) ? 0
198 : 127 * (c - pDimRgn->Crossfade.in_start) / (pDimRgn->Crossfade.in_end - pDimRgn->Crossfade.in_start))
199 : (c <= pDimRgn->Crossfade.out_start) ? 127
200 : (c < pDimRgn->Crossfade.out_end) ? 127 * (pDimRgn->Crossfade.out_end - c) / (pDimRgn->Crossfade.out_end - pDimRgn->Crossfade.out_start)
201 : 0;
202 return pDimRgn->InvertAttenuationController ? 127 - c : c;
203 }
204
205 inline float Constrain(float ValueToCheck, float Min, float Max) {
206 if (ValueToCheck > Max) ValueToCheck = Max;
207 else if (ValueToCheck < Min) ValueToCheck = Min;
208 return ValueToCheck;
209 }
210 };
211
212 }} // namespace LinuxSampler::gig
213
214 #endif // __LS_GIG_VOICE_H__

  ViewVC Help
Powered by ViewVC