/[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 830 - (show annotations) (download) (as text)
Sun Jan 15 18:23:11 2006 UTC (14 years, 1 month ago) by persson
File MIME type: text/x-c++hdr
File size: 13175 byte(s)
* added linear interpolation of volume modulation inside a
  subfragment; this prevents clicks during voice stealing. Can be
  switched off with the --disable-interpolate-volume configure option.

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/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 void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
126
127 //private:
128 // Types
129 enum playback_state_t {
130 playback_state_end = 0,
131 playback_state_init = 1,
132 playback_state_ram = 2,
133 playback_state_disk = 3
134 };
135
136 // Attributes
137 EngineChannel* pEngineChannel;
138 Engine* pEngine; ///< Pointer to the sampler engine, to be able to access the event lists.
139 float Volume; ///< Volume level of the voice
140 float PanLeft;
141 float PanRight;
142 float CrossfadeVolume; ///< Current attenuation level caused by a crossfade (only if a crossfade is defined of course)
143 double Pos; ///< Current playback position in sample
144 float PitchBase; ///< Basic pitch depth, stays the same for the whole life time of the voice
145 float PitchBend; ///< Current pitch value of the pitchbend wheel
146 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
147 ::gig::Sample* pSample; ///< Pointer to the sample to be played back
148 ::gig::DimensionRegion* pDimRgn; ///< Pointer to the articulation information of current dimension region of this voice
149 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
150 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
151 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
152 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
153 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.
154 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
155 //uint LoopCyclesLeft; ///< In case there is a RAMLoop and it's not an endless loop; reflects number of loop cycles left to be passed
156 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
157 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
158 EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
159 EGDecay EG3; ///< Envelope Generator 3 (Pitch)
160 midi_ctrl VCFCutoffCtrl;
161 midi_ctrl VCFResonanceCtrl;
162 static const float FILTER_CUTOFF_COEFF;
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 fFinalVolume;
175 float fFinalCutoff;
176 float fFinalResonance;
177 SynthesisParam finalSynthesisParameters;
178 Loop loop;
179
180 // Static Methods
181 static float CalculateFilterCutoffCoeff();
182
183 // Methods
184 void KillImmediately();
185 void ProcessEvents(uint Samples);
186 void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
187 void processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End);
188 void processCCEvents(RTList<Event>::Iterator& itEvent, uint End);
189 void processPitchEvent(RTList<Event>::Iterator& itEvent);
190 void processCrossFadeEvent(RTList<Event>::Iterator& itEvent);
191 void processCutoffEvent(RTList<Event>::Iterator& itEvent);
192 void processResonanceEvent(RTList<Event>::Iterator& itEvent);
193 float getVolume();
194
195 inline float CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
196 float att = (!pDimRgn->Crossfade.out_end) ? CrossfadeControllerValue / 127.0f /* 0,0,0,0 means no crossfade defined */
197 : (CrossfadeControllerValue < pDimRgn->Crossfade.in_end) ?
198 ((CrossfadeControllerValue <= pDimRgn->Crossfade.in_start) ? 0.0f
199 : float(CrossfadeControllerValue - pDimRgn->Crossfade.in_start) / float(pDimRgn->Crossfade.in_end - pDimRgn->Crossfade.in_start))
200 : (CrossfadeControllerValue <= pDimRgn->Crossfade.out_start) ? 1.0f
201 : (CrossfadeControllerValue < pDimRgn->Crossfade.out_end) ? float(pDimRgn->Crossfade.out_end - CrossfadeControllerValue) / float(pDimRgn->Crossfade.out_end - pDimRgn->Crossfade.out_start)
202 : 0.0f;
203 return pDimRgn->InvertAttenuationController ? 1 - att : att;
204 }
205
206 inline float Constrain(float ValueToCheck, float Min, float Max) {
207 if (ValueToCheck > Max) ValueToCheck = Max;
208 else if (ValueToCheck < Min) ValueToCheck = Min;
209 return ValueToCheck;
210 }
211 };
212
213 }} // namespace LinuxSampler::gig
214
215 #endif // __LS_GIG_VOICE_H__

  ViewVC Help
Powered by ViewVC