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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 877 - (hide 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 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 829 * Copyright (C) 2005, 2006 Christian Schoenebeck *
7 schoenebeck 53 * *
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 schoenebeck 505 #include <gig.h>
30    
31 schoenebeck 53 #include "../../common/RTMath.h"
32 schoenebeck 273 #include "../../common/Pool.h"
33 schoenebeck 203 #include "../../drivers/audio/AudioOutputDevice.h"
34 schoenebeck 53 #include "Engine.h"
35 schoenebeck 411 #include "EngineChannel.h"
36 schoenebeck 53 #include "Stream.h"
37     #include "DiskThread.h"
38 schoenebeck 738 #include "EGADSR.h"
39 schoenebeck 53 #include "EGDecay.h"
40     #include "Filter.h"
41 schoenebeck 738 #include "../common/LFOBase.h"
42 schoenebeck 770 #include "SynthesisParam.h"
43 persson 832 #include "SmoothVolume.h"
44 schoenebeck 53
45 schoenebeck 738 // 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 schoenebeck 53 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 schoenebeck 738 #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 schoenebeck 53 /** Gig Voice
95     *
96     * Renders a voice for the Gigasampler format.
97     */
98     class Voice {
99     public:
100 schoenebeck 242 // 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 persson 832
107 schoenebeck 53 // Attributes
108 schoenebeck 242 type_t Type; ///< Voice Type
109 schoenebeck 53 int MIDIKey; ///< MIDI key number of the key that triggered the voice
110 schoenebeck 239 uint KeyGroup;
111 schoenebeck 53 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 letz 502 virtual ~Voice();
116 schoenebeck 271 void Kill(Pool<Event>::Iterator& itKillEvent);
117 schoenebeck 53 void Render(uint Samples);
118     void Reset();
119     void SetOutput(AudioOutputDevice* pAudioOutputDevice);
120     void SetEngine(Engine* pEngine);
121 schoenebeck 669 int Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup);
122 schoenebeck 285 inline bool IsActive() { return PlaybackState; }
123 schoenebeck 663 inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
124 schoenebeck 829 void UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent);
125    
126 schoenebeck 319 //private:
127 schoenebeck 53 // Types
128     enum playback_state_t {
129 schoenebeck 285 playback_state_end = 0,
130 schoenebeck 563 playback_state_init = 1,
131     playback_state_ram = 2,
132     playback_state_disk = 3
133 schoenebeck 53 };
134    
135     // Attributes
136 schoenebeck 411 EngineChannel* pEngineChannel;
137     Engine* pEngine; ///< Pointer to the sampler engine, to be able to access the event lists.
138 persson 832 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 persson 783 double Pos; ///< Current playback position in sample
145 schoenebeck 319 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 persson 729 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
148 schoenebeck 53 ::gig::Sample* pSample; ///< Pointer to the sample to be played back
149 schoenebeck 236 ::gig::DimensionRegion* pDimRgn; ///< Pointer to the articulation information of current dimension region of this voice
150 schoenebeck 53 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 schoenebeck 330 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
154 schoenebeck 53 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 schoenebeck 770 //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 schoenebeck 53 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 schoenebeck 738 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
159     EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
160     EGDecay EG3; ///< Envelope Generator 3 (Pitch)
161 schoenebeck 53 midi_ctrl VCFCutoffCtrl;
162     midi_ctrl VCFResonanceCtrl;
163 schoenebeck 738 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 schoenebeck 687 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 schoenebeck 271 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 schoenebeck 319 //public: // FIXME: just made public for debugging (sanity check in Engine::RenderAudio()), should be changed to private before the final release
171 schoenebeck 271 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
172 schoenebeck 319 //private:
173     int SynthesisMode;
174 schoenebeck 738 float fFinalCutoff;
175     float fFinalResonance;
176 schoenebeck 770 SynthesisParam finalSynthesisParameters;
177     Loop loop;
178 schoenebeck 738
179 schoenebeck 53 // Static Methods
180     static float CalculateFilterCutoffCoeff();
181    
182     // Methods
183 schoenebeck 319 void KillImmediately();
184     void ProcessEvents(uint Samples);
185 senkov 325 void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
186 schoenebeck 738 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 schoenebeck 245
193 persson 832 inline uint8_t CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
194 persson 831 uint8_t c = std::max(CrossfadeControllerValue, pDimRgn->AttenuationControllerThreshold);
195 persson 832 c = (!pDimRgn->Crossfade.out_end) ? c /* 0,0,0,0 means no crossfade defined */
196 persson 831 : (c < pDimRgn->Crossfade.in_end) ?
197 persson 832 ((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 schoenebeck 236 }
204    
205 schoenebeck 53 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