/[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 783 - (hide annotations) (download) (as text)
Sun Oct 2 14:40:52 2005 UTC (18 years, 6 months ago) by persson
File MIME type: text/x-c++hdr
File size: 13066 byte(s)
* EG fixes: the length of "attack hold" stage was wrong. Release stage
  can now start before attack stage ends. Cancel release didn't work
  when sustain was zero.

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 411 * Copyright (C) 2005 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     #include "../../common/RingBuffer.h"
33 schoenebeck 273 #include "../../common/Pool.h"
34 schoenebeck 203 #include "../../drivers/audio/AudioOutputDevice.h"
35 schoenebeck 80 #include "../common/BiquadFilter.h"
36 schoenebeck 53 #include "Engine.h"
37 schoenebeck 411 #include "EngineChannel.h"
38 schoenebeck 53 #include "Stream.h"
39     #include "DiskThread.h"
40 schoenebeck 738 #include "EGADSR.h"
41 schoenebeck 53 #include "EGDecay.h"
42     #include "Filter.h"
43 schoenebeck 738 #include "../common/LFOBase.h"
44 schoenebeck 770 #include "SynthesisParam.h"
45 schoenebeck 53
46 schoenebeck 738 // 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 schoenebeck 53 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 schoenebeck 738 #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 schoenebeck 53 /** Gig Voice
96     *
97     * Renders a voice for the Gigasampler format.
98     */
99     class Voice {
100     public:
101 schoenebeck 242 // 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 schoenebeck 738
108 schoenebeck 53 // Attributes
109 schoenebeck 242 type_t Type; ///< Voice Type
110 schoenebeck 53 int MIDIKey; ///< MIDI key number of the key that triggered the voice
111 schoenebeck 239 uint KeyGroup;
112 schoenebeck 53 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 letz 502 virtual ~Voice();
117 schoenebeck 271 void Kill(Pool<Event>::Iterator& itKillEvent);
118 schoenebeck 53 void Render(uint Samples);
119     void Reset();
120     void SetOutput(AudioOutputDevice* pAudioOutputDevice);
121     void SetEngine(Engine* pEngine);
122 schoenebeck 669 int Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup);
123 schoenebeck 285 inline bool IsActive() { return PlaybackState; }
124 schoenebeck 663 inline bool IsStealable() { return !itKillEvent && PlaybackState >= playback_state_ram; }
125 schoenebeck 319 //private:
126 schoenebeck 53 // Types
127     enum playback_state_t {
128 schoenebeck 285 playback_state_end = 0,
129 schoenebeck 563 playback_state_init = 1,
130     playback_state_ram = 2,
131     playback_state_disk = 3
132 schoenebeck 53 };
133    
134     // Attributes
135 schoenebeck 411 EngineChannel* pEngineChannel;
136     Engine* pEngine; ///< Pointer to the sampler engine, to be able to access the event lists.
137 schoenebeck 53 float Volume; ///< Volume level of the voice
138 schoenebeck 245 float PanLeft;
139     float PanRight;
140 schoenebeck 236 float CrossfadeVolume; ///< Current attenuation level caused by a crossfade (only if a crossfade is defined of course)
141 persson 783 double Pos; ///< Current playback position in sample
142 schoenebeck 319 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 persson 729 float CutoffBase; ///< Cutoff frequency before control change, EG and LFO are applied
145 schoenebeck 53 ::gig::Sample* pSample; ///< Pointer to the sample to be played back
146 schoenebeck 236 ::gig::DimensionRegion* pDimRgn; ///< Pointer to the articulation information of current dimension region of this voice
147 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
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 schoenebeck 330 int RealSampleWordsLeftToRead; ///< Number of samples left to read, not including the silence added for the interpolator
151 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.
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 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
154 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
155 schoenebeck 738 EGADSR EG1; ///< Envelope Generator 1 (Amplification)
156     EGADSR EG2; ///< Envelope Generator 2 (Filter cutoff frequency)
157     EGDecay EG3; ///< Envelope Generator 3 (Pitch)
158 schoenebeck 53 midi_ctrl VCFCutoffCtrl;
159     midi_ctrl VCFResonanceCtrl;
160     static const float FILTER_CUTOFF_COEFF;
161 schoenebeck 738 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 schoenebeck 687 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 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).
168 schoenebeck 319 //public: // FIXME: just made public for debugging (sanity check in Engine::RenderAudio()), should be changed to private before the final release
169 schoenebeck 271 Pool<Event>::Iterator itKillEvent; ///< Event which caused this voice to be killed
170 schoenebeck 319 //private:
171     int SynthesisMode;
172 schoenebeck 738 float fFinalVolume;
173     float fFinalCutoff;
174     float fFinalResonance;
175 schoenebeck 770 SynthesisParam finalSynthesisParameters;
176     Loop loop;
177 schoenebeck 738
178 schoenebeck 53 // Static Methods
179     static float CalculateFilterCutoffCoeff();
180    
181     // Methods
182 schoenebeck 319 void KillImmediately();
183     void ProcessEvents(uint Samples);
184 senkov 325 void Synthesize(uint Samples, sample_t* pSrc, uint Skip);
185 schoenebeck 738 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 schoenebeck 245
192 schoenebeck 236 inline float CrossfadeAttenuation(uint8_t& CrossfadeControllerValue) {
193 schoenebeck 348 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 schoenebeck 236 }
202    
203 schoenebeck 53 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