/[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 1424 - (show annotations) (download) (as text)
Sun Oct 14 22:00:17 2007 UTC (16 years, 5 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 13634 byte(s)
* code cleanup:
- global.h now only covers global definitions that are needed for the C++
  API header files, all implementation internal global definitions are now
  in global_private.h
- atomic.h is not exposed to the C++ API anymore (replaced the references
  in SynchronizedConfig.h for this with local definitions)
- no need to include config.h anymore for using LS's API header files
- DB instruments classes are not exposed to the C++ API
- POSIX callback functions of Thread.h are hidden
- the (optional) gig Engine benchmark compiles again
- updated Doxyfile.in
- fixed warnings in API doc generation
* preparations for release 0.5.0

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2007 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_private.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 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.
151 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
152 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
153 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
154 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
155 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.
156 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
157 //uint LoopCyclesLeft; ///< In case there is a RAMLoop and it's not an endless loop; reflects number of loop cycles left to be passed
158 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
159 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
160 EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
161 EGDecay EG3; ///< Envelope Generator 3 (Pitch)
162 midi_ctrl VCFCutoffCtrl;
163 midi_ctrl VCFResonanceCtrl;
164 LFOUnsigned* pLFO1; ///< Low Frequency Oscillator 1 (Amplification)
165 LFOUnsigned* pLFO2; ///< Low Frequency Oscillator 2 (Filter cutoff frequency)
166 LFOSigned* pLFO3; ///< Low Frequency Oscillator 3 (Pitch)
167 bool bLFO1Enabled; ///< Should we use the Amplitude LFO for this voice?
168 bool bLFO2Enabled; ///< Should we use the Filter Cutoff LFO for this voice?
169 bool bLFO3Enabled; ///< Should we use the Pitch LFO for this voice?
170 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).
171 //public: // FIXME: just made public for debugging (sanity check in Engine::RenderAudio()), should be changed to private before the final release
172 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
173 //private:
174 int SynthesisMode;
175 float fFinalCutoff;
176 float fFinalResonance;
177 SynthesisParam finalSynthesisParameters;
178 Loop loop;
179
180 // Static Methods
181 static float CalculateFilterCutoffCoeff();
182
183 // Methods
184 Stream::Handle KillImmediately(bool bRequestNotification = false);
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
194 inline uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
195 uint8_t c = std::max(CrossfadeControllerValue, pDimRgn->AttenuationControllerThreshold);
196 c = (!pDimRgn->Crossfade.out_end) ? c /* 0,0,0,0 means no crossfade defined */
197 : (c < pDimRgn->Crossfade.in_end) ?
198 ((c <= pDimRgn->Crossfade.in_start) ? 0
199 : 127 * (c - pDimRgn->Crossfade.in_start) / (pDimRgn->Crossfade.in_end - pDimRgn->Crossfade.in_start))
200 : (c <= pDimRgn->Crossfade.out_start) ? 127
201 : (c < pDimRgn->Crossfade.out_end) ? 127 * (pDimRgn->Crossfade.out_end - c) / (pDimRgn->Crossfade.out_end - pDimRgn->Crossfade.out_start)
202 : 0;
203 return pDimRgn->InvertAttenuationController ? 127 - c : c;
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