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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 696 - (hide annotations) (download)
Sat Jul 16 19:37:52 2005 UTC (18 years, 7 months ago) by persson
File size: 48519 byte(s)
* fine tuning of the EG modulation parameters

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     #include "EGADSR.h"
25     #include "Manipulator.h"
26 schoenebeck 319 #include "../../common/Features.h"
27     #include "Synthesizer.h"
28 schoenebeck 53
29     #include "Voice.h"
30    
31     namespace LinuxSampler { namespace gig {
32    
33     const float Voice::FILTER_CUTOFF_COEFF(CalculateFilterCutoffCoeff());
34    
35 schoenebeck 80 const int Voice::FILTER_UPDATE_MASK(CalculateFilterUpdateMask());
36    
37 schoenebeck 53 float Voice::CalculateFilterCutoffCoeff() {
38 schoenebeck 554 return log(CONFIG_FILTER_CUTOFF_MIN / CONFIG_FILTER_CUTOFF_MAX);
39 schoenebeck 53 }
40    
41 schoenebeck 80 int Voice::CalculateFilterUpdateMask() {
42 schoenebeck 554 if (CONFIG_FILTER_UPDATE_STEPS <= 0) return 0;
43 schoenebeck 80 int power_of_two;
44 schoenebeck 554 for (power_of_two = 0; 1<<power_of_two < CONFIG_FILTER_UPDATE_STEPS; power_of_two++);
45 schoenebeck 80 return (1 << power_of_two) - 1;
46     }
47    
48 schoenebeck 53 Voice::Voice() {
49     pEngine = NULL;
50     pDiskThread = NULL;
51 schoenebeck 285 PlaybackState = playback_state_end;
52 schoenebeck 53 pEG1 = NULL;
53     pEG2 = NULL;
54     pEG3 = NULL;
55     pVCAManipulator = NULL;
56     pVCFCManipulator = NULL;
57     pVCOManipulator = NULL;
58     pLFO1 = NULL;
59     pLFO2 = NULL;
60     pLFO3 = NULL;
61 schoenebeck 239 KeyGroup = 0;
62 schoenebeck 361 SynthesisMode = 0; // set all mode bits to 0 first
63 schoenebeck 319 // select synthesis implementation (currently either pure C++ or MMX+SSE(1))
64 schoenebeck 617 #if CONFIG_ASM && ARCH_X86
65 schoenebeck 319 SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());
66 schoenebeck 361 #else
67     SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, false);
68     #endif
69 senkov 325 SYNTHESIS_MODE_SET_PROFILING(SynthesisMode, true);
70 schoenebeck 368
71     FilterLeft.Reset();
72     FilterRight.Reset();
73 schoenebeck 53 }
74    
75     Voice::~Voice() {
76     if (pEG1) delete pEG1;
77     if (pEG2) delete pEG2;
78     if (pEG3) delete pEG3;
79     if (pLFO1) delete pLFO1;
80     if (pLFO2) delete pLFO2;
81     if (pLFO3) delete pLFO3;
82     if (pVCAManipulator) delete pVCAManipulator;
83     if (pVCFCManipulator) delete pVCFCManipulator;
84     if (pVCOManipulator) delete pVCOManipulator;
85     }
86    
87     void Voice::SetEngine(Engine* pEngine) {
88     this->pEngine = pEngine;
89    
90     // delete old objects
91     if (pEG1) delete pEG1;
92     if (pEG2) delete pEG2;
93     if (pEG3) delete pEG3;
94     if (pVCAManipulator) delete pVCAManipulator;
95     if (pVCFCManipulator) delete pVCFCManipulator;
96     if (pVCOManipulator) delete pVCOManipulator;
97     if (pLFO1) delete pLFO1;
98     if (pLFO2) delete pLFO2;
99     if (pLFO3) delete pLFO3;
100    
101     // create new ones
102     pEG1 = new EGADSR(pEngine, Event::destination_vca);
103     pEG2 = new EGADSR(pEngine, Event::destination_vcfc);
104     pEG3 = new EGDecay(pEngine, Event::destination_vco);
105     pVCAManipulator = new VCAManipulator(pEngine);
106     pVCFCManipulator = new VCFCManipulator(pEngine);
107     pVCOManipulator = new VCOManipulator(pEngine);
108     pLFO1 = new LFO<gig::VCAManipulator>(0.0f, 1.0f, LFO<VCAManipulator>::propagation_top_down, pVCAManipulator, pEngine->pEventPool);
109     pLFO2 = new LFO<gig::VCFCManipulator>(0.0f, 1.0f, LFO<VCFCManipulator>::propagation_top_down, pVCFCManipulator, pEngine->pEventPool);
110     pLFO3 = new LFO<gig::VCOManipulator>(-1200.0f, 1200.0f, LFO<VCOManipulator>::propagation_middle_balanced, pVCOManipulator, pEngine->pEventPool); // +-1 octave (+-1200 cents) max.
111    
112     this->pDiskThread = pEngine->pDiskThread;
113 schoenebeck 64 dmsg(6,("Voice::SetEngine()\n"));
114 schoenebeck 53 }
115    
116     /**
117     * Initializes and triggers the voice, a disk stream will be launched if
118     * needed.
119     *
120 schoenebeck 669 * @param pEngineChannel - engine channel on which this voice was ordered
121     * @param itNoteOnEvent - event that caused triggering of this voice
122     * @param PitchBend - MIDI detune factor (-8192 ... +8191)
123     * @param pDimRgn - points to the dimension region which provides sample wave(s) and articulation data
124     * @param VoiceType - type of this voice
125     * @param iKeyGroup - a value > 0 defines a key group in which this voice is member of
126 schoenebeck 354 * @returns 0 on success, a value < 0 if the voice wasn't triggered
127     * (either due to an error or e.g. because no region is
128     * defined for the given key)
129 schoenebeck 53 */
130 schoenebeck 669 int Voice::Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup) {
131 schoenebeck 411 this->pEngineChannel = pEngineChannel;
132 schoenebeck 669 this->pDimRgn = pDimRgn;
133    
134 schoenebeck 563 #if CONFIG_DEVMODE
135     if (itNoteOnEvent->FragmentPos() > pEngine->MaxSamplesPerCycle) { // just a sanity check for debugging
136 schoenebeck 319 dmsg(1,("Voice::Trigger(): ERROR, TriggerDelay > Totalsamples\n"));
137     }
138 schoenebeck 563 #endif // CONFIG_DEVMODE
139 schoenebeck 53
140 schoenebeck 669 Type = VoiceType;
141 schoenebeck 271 MIDIKey = itNoteOnEvent->Param.Note.Key;
142 schoenebeck 563 PlaybackState = playback_state_init; // mark voice as triggered, but no audio rendered yet
143 schoenebeck 271 Delay = itNoteOnEvent->FragmentPos();
144     itTriggerEvent = itNoteOnEvent;
145     itKillEvent = Pool<Event>::Iterator();
146 schoenebeck 669 KeyGroup = iKeyGroup;
147     pSample = pDimRgn->pSample; // sample won't change until the voice is finished
148 schoenebeck 53
149 persson 630 // calculate volume
150     const double velocityAttenuation = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity);
151    
152     Volume = velocityAttenuation / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)
153    
154     Volume *= pDimRgn->SampleAttenuation;
155    
156     // the volume of release triggered samples depends on note length
157 schoenebeck 669 if (Type == type_release_trigger) {
158 persson 630 float noteLength = float(pEngine->FrameTime + Delay -
159     pEngineChannel->pMIDIKeyInfo[MIDIKey].NoteOnTime) / pEngine->SampleRate;
160     float attenuation = 1 - 0.01053 * (256 >> pDimRgn->ReleaseTriggerDecay) * noteLength;
161     if (attenuation <= 0) return -1;
162     Volume *= attenuation;
163     }
164    
165 schoenebeck 319 // select channel mode (mono or stereo)
166     SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);
167    
168 schoenebeck 236 // get starting crossfade volume level
169     switch (pDimRgn->AttenuationController.type) {
170     case ::gig::attenuation_ctrl_t::type_channelaftertouch:
171     CrossfadeVolume = 1.0f; //TODO: aftertouch not supported yet
172     break;
173     case ::gig::attenuation_ctrl_t::type_velocity:
174 schoenebeck 271 CrossfadeVolume = CrossfadeAttenuation(itNoteOnEvent->Param.Note.Velocity);
175 schoenebeck 236 break;
176     case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate
177 schoenebeck 411 CrossfadeVolume = CrossfadeAttenuation(pEngineChannel->ControllerTable[pDimRgn->AttenuationController.controller_number]);
178 schoenebeck 236 break;
179     case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined
180     default:
181     CrossfadeVolume = 1.0f;
182     }
183    
184 schoenebeck 271 PanLeft = 1.0f - float(RTMath::Max(pDimRgn->Pan, 0)) / 63.0f;
185     PanRight = 1.0f - float(RTMath::Min(pDimRgn->Pan, 0)) / -64.0f;
186 schoenebeck 245
187 schoenebeck 236 Pos = pDimRgn->SampleStartOffset; // offset where we should start playback of sample (0 - 2000 sample points)
188    
189 schoenebeck 53 // Check if the sample needs disk streaming or is too short for that
190     long cachedsamples = pSample->GetCache().Size / pSample->FrameSize;
191     DiskVoice = cachedsamples < pSample->SamplesTotal;
192    
193     if (DiskVoice) { // voice to be streamed from disk
194 schoenebeck 554 MaxRAMPos = cachedsamples - (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH) / pSample->Channels; //TODO: this calculation is too pessimistic and may better be moved to Render() method, so it calculates MaxRAMPos dependent to the current demand of sample points to be rendered (e.g. in case of JACK)
195 schoenebeck 53
196     // check if there's a loop defined which completely fits into the cached (RAM) part of the sample
197     if (pSample->Loops && pSample->LoopEnd <= MaxRAMPos) {
198     RAMLoop = true;
199     LoopCyclesLeft = pSample->LoopPlayCount;
200     }
201     else RAMLoop = false;
202    
203     if (pDiskThread->OrderNewStream(&DiskStreamRef, pSample, MaxRAMPos, !RAMLoop) < 0) {
204     dmsg(1,("Disk stream order failed!\n"));
205 schoenebeck 239 KillImmediately();
206 schoenebeck 53 return -1;
207     }
208     dmsg(4,("Disk voice launched (cached samples: %d, total Samples: %d, MaxRAMPos: %d, RAMLooping: %s)\n", cachedsamples, pSample->SamplesTotal, MaxRAMPos, (RAMLoop) ? "yes" : "no"));
209     }
210     else { // RAM only voice
211     MaxRAMPos = cachedsamples;
212     if (pSample->Loops) {
213     RAMLoop = true;
214     LoopCyclesLeft = pSample->LoopPlayCount;
215     }
216     else RAMLoop = false;
217     dmsg(4,("RAM only voice launched (Looping: %s)\n", (RAMLoop) ? "yes" : "no"));
218     }
219    
220    
221     // calculate initial pitch value
222     {
223 senkov 335 double pitchbasecents = pDimRgn->FineTune + (int) pEngine->ScaleTuning[MIDIKey % 12];
224 schoenebeck 53 if (pDimRgn->PitchTrack) pitchbasecents += (MIDIKey - (int) pDimRgn->UnityNote) * 100;
225 schoenebeck 233 this->PitchBase = RTMath::CentsToFreqRatio(pitchbasecents) * (double(pSample->SamplesPerSecond) / double(pEngine->pAudioOutputDevice->SampleRate()));
226 schoenebeck 53 this->PitchBend = RTMath::CentsToFreqRatio(((double) PitchBend / 8192.0) * 200.0); // pitchbend wheel +-2 semitones = 200 cents
227     }
228    
229 persson 614 // the length of the decay and release curves are dependent on the velocity
230     const double velrelease = 1 / pDimRgn->GetVelocityRelease(itNoteOnEvent->Param.Note.Velocity);
231    
232 schoenebeck 53 // setup EG 1 (VCA EG)
233     {
234     // get current value of EG1 controller
235     double eg1controllervalue;
236     switch (pDimRgn->EG1Controller.type) {
237     case ::gig::eg1_ctrl_t::type_none: // no controller defined
238     eg1controllervalue = 0;
239     break;
240     case ::gig::eg1_ctrl_t::type_channelaftertouch:
241     eg1controllervalue = 0; // TODO: aftertouch not yet supported
242     break;
243     case ::gig::eg1_ctrl_t::type_velocity:
244 schoenebeck 271 eg1controllervalue = itNoteOnEvent->Param.Note.Velocity;
245 schoenebeck 53 break;
246     case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller
247 schoenebeck 411 eg1controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG1Controller.controller_number];
248 schoenebeck 53 break;
249     }
250     if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;
251    
252 persson 696 // calculate influence of EG1 controller on EG1's parameters
253     // (eg1attack is different from the others)
254     double eg1attack = (pDimRgn->EG1ControllerAttackInfluence) ?
255     1 + 0.031 * (double) (pDimRgn->EG1ControllerAttackInfluence == 1 ?
256     1 : 1 << pDimRgn->EG1ControllerAttackInfluence) * eg1controllervalue : 1.0;
257     double eg1decay = (pDimRgn->EG1ControllerDecayInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerDecayInfluence) * eg1controllervalue : 1.0;
258     double eg1release = (pDimRgn->EG1ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerReleaseInfluence) * eg1controllervalue : 1.0;
259 schoenebeck 53
260     pEG1->Trigger(pDimRgn->EG1PreAttack,
261 persson 696 pDimRgn->EG1Attack * eg1attack,
262 schoenebeck 53 pDimRgn->EG1Hold,
263     pSample->LoopStart,
264 persson 696 pDimRgn->EG1Decay1 * eg1decay * velrelease,
265     pDimRgn->EG1Decay2 * eg1decay * velrelease,
266 schoenebeck 53 pDimRgn->EG1InfiniteSustain,
267     pDimRgn->EG1Sustain,
268 persson 696 pDimRgn->EG1Release * eg1release * velrelease,
269 persson 425 // the SSE synthesis implementation requires
270     // the vca start to be 16 byte aligned
271     SYNTHESIS_MODE_GET_IMPLEMENTATION(SynthesisMode) ?
272 persson 614 Delay & 0xfffffffc : Delay,
273     velocityAttenuation);
274 schoenebeck 53 }
275    
276    
277     // setup EG 2 (VCF Cutoff EG)
278     {
279     // get current value of EG2 controller
280     double eg2controllervalue;
281     switch (pDimRgn->EG2Controller.type) {
282     case ::gig::eg2_ctrl_t::type_none: // no controller defined
283     eg2controllervalue = 0;
284     break;
285     case ::gig::eg2_ctrl_t::type_channelaftertouch:
286     eg2controllervalue = 0; // TODO: aftertouch not yet supported
287     break;
288     case ::gig::eg2_ctrl_t::type_velocity:
289 schoenebeck 271 eg2controllervalue = itNoteOnEvent->Param.Note.Velocity;
290 schoenebeck 53 break;
291     case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller
292 schoenebeck 411 eg2controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG2Controller.controller_number];
293 schoenebeck 53 break;
294     }
295     if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;
296    
297 persson 696 // calculate influence of EG2 controller on EG2's parameters
298     double eg2attack = (pDimRgn->EG2ControllerAttackInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerAttackInfluence) * eg2controllervalue : 1.0;
299     double eg2decay = (pDimRgn->EG2ControllerDecayInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerDecayInfluence) * eg2controllervalue : 1.0;
300     double eg2release = (pDimRgn->EG2ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerReleaseInfluence) * eg2controllervalue : 1.0;
301 schoenebeck 53
302     pEG2->Trigger(pDimRgn->EG2PreAttack,
303 persson 696 pDimRgn->EG2Attack * eg2attack,
304 schoenebeck 53 false,
305     pSample->LoopStart,
306 persson 696 pDimRgn->EG2Decay1 * eg2decay * velrelease,
307     pDimRgn->EG2Decay2 * eg2decay * velrelease,
308 schoenebeck 53 pDimRgn->EG2InfiniteSustain,
309     pDimRgn->EG2Sustain,
310 persson 696 pDimRgn->EG2Release * eg2release * velrelease,
311 persson 614 Delay,
312     velocityAttenuation);
313 schoenebeck 53 }
314    
315    
316     // setup EG 3 (VCO EG)
317     {
318     double eg3depth = RTMath::CentsToFreqRatio(pDimRgn->EG3Depth);
319     pEG3->Trigger(eg3depth, pDimRgn->EG3Attack, Delay);
320     }
321    
322    
323     // setup LFO 1 (VCA LFO)
324     {
325     uint16_t lfo1_internal_depth;
326     switch (pDimRgn->LFO1Controller) {
327     case ::gig::lfo1_ctrl_internal:
328     lfo1_internal_depth = pDimRgn->LFO1InternalDepth;
329     pLFO1->ExtController = 0; // no external controller
330 schoenebeck 687 bLFO1Enabled = (lfo1_internal_depth > 0);
331 schoenebeck 53 break;
332     case ::gig::lfo1_ctrl_modwheel:
333     lfo1_internal_depth = 0;
334     pLFO1->ExtController = 1; // MIDI controller 1
335 schoenebeck 687 bLFO1Enabled = (pDimRgn->LFO1ControlDepth > 0);
336 schoenebeck 53 break;
337     case ::gig::lfo1_ctrl_breath:
338     lfo1_internal_depth = 0;
339     pLFO1->ExtController = 2; // MIDI controller 2
340 schoenebeck 687 bLFO1Enabled = (pDimRgn->LFO1ControlDepth > 0);
341 schoenebeck 53 break;
342     case ::gig::lfo1_ctrl_internal_modwheel:
343     lfo1_internal_depth = pDimRgn->LFO1InternalDepth;
344     pLFO1->ExtController = 1; // MIDI controller 1
345 schoenebeck 687 bLFO1Enabled = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
346 schoenebeck 53 break;
347     case ::gig::lfo1_ctrl_internal_breath:
348     lfo1_internal_depth = pDimRgn->LFO1InternalDepth;
349     pLFO1->ExtController = 2; // MIDI controller 2
350 schoenebeck 687 bLFO1Enabled = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
351 schoenebeck 53 break;
352     default:
353     lfo1_internal_depth = 0;
354     pLFO1->ExtController = 0; // no external controller
355 schoenebeck 687 bLFO1Enabled = false;
356 schoenebeck 53 }
357 schoenebeck 687 if (bLFO1Enabled) pLFO1->Trigger(pDimRgn->LFO1Frequency,
358     lfo1_internal_depth,
359     pDimRgn->LFO1ControlDepth,
360     pEngineChannel->ControllerTable[pLFO1->ExtController],
361     pDimRgn->LFO1FlipPhase,
362     pEngine->SampleRate,
363     Delay);
364 schoenebeck 53 }
365    
366 schoenebeck 319
367 schoenebeck 53 // setup LFO 2 (VCF Cutoff LFO)
368     {
369     uint16_t lfo2_internal_depth;
370     switch (pDimRgn->LFO2Controller) {
371     case ::gig::lfo2_ctrl_internal:
372     lfo2_internal_depth = pDimRgn->LFO2InternalDepth;
373     pLFO2->ExtController = 0; // no external controller
374 schoenebeck 687 bLFO2Enabled = (lfo2_internal_depth > 0);
375 schoenebeck 53 break;
376     case ::gig::lfo2_ctrl_modwheel:
377     lfo2_internal_depth = 0;
378     pLFO2->ExtController = 1; // MIDI controller 1
379 schoenebeck 687 bLFO2Enabled = (pDimRgn->LFO2ControlDepth > 0);
380 schoenebeck 53 break;
381     case ::gig::lfo2_ctrl_foot:
382     lfo2_internal_depth = 0;
383     pLFO2->ExtController = 4; // MIDI controller 4
384 schoenebeck 687 bLFO2Enabled = (pDimRgn->LFO2ControlDepth > 0);
385 schoenebeck 53 break;
386     case ::gig::lfo2_ctrl_internal_modwheel:
387     lfo2_internal_depth = pDimRgn->LFO2InternalDepth;
388     pLFO2->ExtController = 1; // MIDI controller 1
389 schoenebeck 687 bLFO2Enabled = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
390 schoenebeck 53 break;
391     case ::gig::lfo2_ctrl_internal_foot:
392     lfo2_internal_depth = pDimRgn->LFO2InternalDepth;
393     pLFO2->ExtController = 4; // MIDI controller 4
394 schoenebeck 687 bLFO2Enabled = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
395 schoenebeck 53 break;
396     default:
397     lfo2_internal_depth = 0;
398     pLFO2->ExtController = 0; // no external controller
399 schoenebeck 687 bLFO2Enabled = false;
400 schoenebeck 53 }
401 schoenebeck 687 if (bLFO2Enabled) pLFO2->Trigger(pDimRgn->LFO2Frequency,
402     lfo2_internal_depth,
403     pDimRgn->LFO2ControlDepth,
404     pEngineChannel->ControllerTable[pLFO2->ExtController],
405     pDimRgn->LFO2FlipPhase,
406     pEngine->SampleRate,
407     Delay);
408 schoenebeck 53 }
409    
410 schoenebeck 319
411 schoenebeck 53 // setup LFO 3 (VCO LFO)
412     {
413     uint16_t lfo3_internal_depth;
414     switch (pDimRgn->LFO3Controller) {
415     case ::gig::lfo3_ctrl_internal:
416     lfo3_internal_depth = pDimRgn->LFO3InternalDepth;
417     pLFO3->ExtController = 0; // no external controller
418 schoenebeck 687 bLFO3Enabled = (lfo3_internal_depth > 0);
419 schoenebeck 53 break;
420     case ::gig::lfo3_ctrl_modwheel:
421     lfo3_internal_depth = 0;
422     pLFO3->ExtController = 1; // MIDI controller 1
423 schoenebeck 687 bLFO3Enabled = (pDimRgn->LFO3ControlDepth > 0);
424 schoenebeck 53 break;
425     case ::gig::lfo3_ctrl_aftertouch:
426     lfo3_internal_depth = 0;
427     pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet
428 schoenebeck 687 bLFO3Enabled = false; // see TODO comment in line above
429 schoenebeck 53 break;
430     case ::gig::lfo3_ctrl_internal_modwheel:
431     lfo3_internal_depth = pDimRgn->LFO3InternalDepth;
432     pLFO3->ExtController = 1; // MIDI controller 1
433 schoenebeck 687 bLFO3Enabled = (lfo3_internal_depth > 0 || pDimRgn->LFO3ControlDepth > 0);
434 schoenebeck 53 break;
435     case ::gig::lfo3_ctrl_internal_aftertouch:
436     lfo3_internal_depth = pDimRgn->LFO3InternalDepth;
437     pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet
438 schoenebeck 687 bLFO3Enabled = (lfo3_internal_depth > 0 /*|| pDimRgn->LFO3ControlDepth > 0*/); // see TODO comment in line above
439 schoenebeck 53 break;
440     default:
441     lfo3_internal_depth = 0;
442     pLFO3->ExtController = 0; // no external controller
443 schoenebeck 687 bLFO3Enabled = false;
444 schoenebeck 53 }
445 schoenebeck 687 if (bLFO3Enabled) pLFO3->Trigger(pDimRgn->LFO3Frequency,
446     lfo3_internal_depth,
447     pDimRgn->LFO3ControlDepth,
448     pEngineChannel->ControllerTable[pLFO3->ExtController],
449     false,
450     pEngine->SampleRate,
451     Delay);
452 schoenebeck 53 }
453    
454 schoenebeck 319
455 schoenebeck 554 #if CONFIG_FORCE_FILTER
456 schoenebeck 368 const bool bUseFilter = true;
457 schoenebeck 53 #else // use filter only if instrument file told so
458 schoenebeck 368 const bool bUseFilter = pDimRgn->VCFEnabled;
459 schoenebeck 554 #endif // CONFIG_FORCE_FILTER
460 schoenebeck 368 SYNTHESIS_MODE_SET_FILTER(SynthesisMode, bUseFilter);
461     if (bUseFilter) {
462 schoenebeck 554 #ifdef CONFIG_OVERRIDE_CUTOFF_CTRL
463     VCFCutoffCtrl.controller = CONFIG_OVERRIDE_CUTOFF_CTRL;
464 schoenebeck 53 #else // use the one defined in the instrument file
465     switch (pDimRgn->VCFCutoffController) {
466     case ::gig::vcf_cutoff_ctrl_modwheel:
467     VCFCutoffCtrl.controller = 1;
468     break;
469     case ::gig::vcf_cutoff_ctrl_effect1:
470     VCFCutoffCtrl.controller = 12;
471     break;
472     case ::gig::vcf_cutoff_ctrl_effect2:
473     VCFCutoffCtrl.controller = 13;
474     break;
475     case ::gig::vcf_cutoff_ctrl_breath:
476     VCFCutoffCtrl.controller = 2;
477     break;
478     case ::gig::vcf_cutoff_ctrl_foot:
479     VCFCutoffCtrl.controller = 4;
480     break;
481     case ::gig::vcf_cutoff_ctrl_sustainpedal:
482     VCFCutoffCtrl.controller = 64;
483     break;
484     case ::gig::vcf_cutoff_ctrl_softpedal:
485     VCFCutoffCtrl.controller = 67;
486     break;
487     case ::gig::vcf_cutoff_ctrl_genpurpose7:
488     VCFCutoffCtrl.controller = 82;
489     break;
490     case ::gig::vcf_cutoff_ctrl_genpurpose8:
491     VCFCutoffCtrl.controller = 83;
492     break;
493     case ::gig::vcf_cutoff_ctrl_aftertouch: //TODO: not implemented yet
494     case ::gig::vcf_cutoff_ctrl_none:
495     default:
496     VCFCutoffCtrl.controller = 0;
497     break;
498     }
499 schoenebeck 554 #endif // CONFIG_OVERRIDE_CUTOFF_CTRL
500 schoenebeck 53
501 schoenebeck 554 #ifdef CONFIG_OVERRIDE_RESONANCE_CTRL
502     VCFResonanceCtrl.controller = CONFIG_OVERRIDE_RESONANCE_CTRL;
503 schoenebeck 53 #else // use the one defined in the instrument file
504     switch (pDimRgn->VCFResonanceController) {
505     case ::gig::vcf_res_ctrl_genpurpose3:
506     VCFResonanceCtrl.controller = 18;
507     break;
508     case ::gig::vcf_res_ctrl_genpurpose4:
509     VCFResonanceCtrl.controller = 19;
510     break;
511     case ::gig::vcf_res_ctrl_genpurpose5:
512     VCFResonanceCtrl.controller = 80;
513     break;
514     case ::gig::vcf_res_ctrl_genpurpose6:
515     VCFResonanceCtrl.controller = 81;
516     break;
517     case ::gig::vcf_res_ctrl_none:
518     default:
519     VCFResonanceCtrl.controller = 0;
520     }
521 schoenebeck 554 #endif // CONFIG_OVERRIDE_RESONANCE_CTRL
522 schoenebeck 53
523 schoenebeck 554 #ifndef CONFIG_OVERRIDE_FILTER_TYPE
524 schoenebeck 53 FilterLeft.SetType(pDimRgn->VCFType);
525     FilterRight.SetType(pDimRgn->VCFType);
526     #else // override filter type
527 schoenebeck 554 FilterLeft.SetType(CONFIG_OVERRIDE_FILTER_TYPE);
528     FilterRight.SetType(CONFIG_OVERRIDE_FILTER_TYPE);
529     #endif // CONFIG_OVERRIDE_FILTER_TYPE
530 schoenebeck 53
531 schoenebeck 411 VCFCutoffCtrl.value = pEngineChannel->ControllerTable[VCFCutoffCtrl.controller];
532     VCFResonanceCtrl.value = pEngineChannel->ControllerTable[VCFResonanceCtrl.controller];
533 schoenebeck 53
534     // calculate cutoff frequency
535     float cutoff = (!VCFCutoffCtrl.controller)
536 schoenebeck 554 ? exp((float) (127 - itNoteOnEvent->Param.Note.Velocity) * (float) pDimRgn->VCFVelocityScale * 6.2E-5f * FILTER_CUTOFF_COEFF) * CONFIG_FILTER_CUTOFF_MAX
537     : exp((float) VCFCutoffCtrl.value * 0.00787402f * FILTER_CUTOFF_COEFF) * CONFIG_FILTER_CUTOFF_MAX;
538 schoenebeck 53
539     // calculate resonance
540     float resonance = (float) VCFResonanceCtrl.value * 0.00787f; // 0.0..1.0
541     if (pDimRgn->VCFKeyboardTracking) {
542 schoenebeck 271 resonance += (float) (itNoteOnEvent->Param.Note.Key - pDimRgn->VCFKeyboardTrackingBreakpoint) * 0.00787f;
543 schoenebeck 53 }
544     Constrain(resonance, 0.0, 1.0); // correct resonance if outside allowed value range (0.0..1.0)
545    
546 schoenebeck 554 VCFCutoffCtrl.fvalue = cutoff - CONFIG_FILTER_CUTOFF_MIN;
547 schoenebeck 53 VCFResonanceCtrl.fvalue = resonance;
548    
549     FilterUpdateCounter = -1;
550     }
551     else {
552     VCFCutoffCtrl.controller = 0;
553     VCFResonanceCtrl.controller = 0;
554     }
555    
556     return 0; // success
557     }
558    
559     /**
560     * Renders the audio data for this voice for the current audio fragment.
561     * The sample input data can either come from RAM (cached sample or sample
562     * part) or directly from disk. The output signal will be rendered by
563     * resampling / interpolation. If this voice is a disk streaming voice and
564     * the voice completely played back the cached RAM part of the sample, it
565     * will automatically switch to disk playback for the next RenderAudio()
566     * call.
567     *
568     * @param Samples - number of samples to be rendered in this audio fragment cycle
569     */
570     void Voice::Render(uint Samples) {
571    
572 schoenebeck 319 // select default values for synthesis mode bits
573     SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, (PitchBase * PitchBend) != 1.0f);
574     SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, true);
575     SYNTHESIS_MODE_SET_LOOP(SynthesisMode, false);
576    
577 schoenebeck 53 // Reset the synthesis parameter matrix
578 schoenebeck 319
579 schoenebeck 411 pEngine->ResetSynthesisParameters(Event::destination_vca, this->Volume * this->CrossfadeVolume * pEngineChannel->GlobalVolume);
580 schoenebeck 53 pEngine->ResetSynthesisParameters(Event::destination_vco, this->PitchBase);
581     pEngine->ResetSynthesisParameters(Event::destination_vcfc, VCFCutoffCtrl.fvalue);
582     pEngine->ResetSynthesisParameters(Event::destination_vcfr, VCFResonanceCtrl.fvalue);
583    
584     // Apply events to the synthesis parameter matrix
585     ProcessEvents(Samples);
586    
587     // Let all modulators write their parameter changes to the synthesis parameter matrix for the current audio fragment
588 schoenebeck 411 pEG1->Process(Samples, pEngineChannel->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend, itKillEvent);
589     pEG2->Process(Samples, pEngineChannel->pMIDIKeyInfo[MIDIKey].pEvents, itTriggerEvent, this->Pos, this->PitchBase * this->PitchBend);
590 schoenebeck 319 if (pEG3->Process(Samples)) { // if pitch EG is active
591     SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
592     SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
593     }
594 schoenebeck 687 if (bLFO1Enabled) pLFO1->Process(Samples);
595     if (bLFO2Enabled) pLFO2->Process(Samples);
596     if (bLFO3Enabled) {
597     if (pLFO3->Process(Samples)) { // if pitch LFO modulation is active
598     SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
599     SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
600     }
601 schoenebeck 319 }
602 schoenebeck 53
603 schoenebeck 319 if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))
604 persson 425 CalculateBiquadParameters(Samples); // calculate the final biquad filter parameters
605 schoenebeck 53
606 schoenebeck 319 switch (this->PlaybackState) {
607 schoenebeck 80
608 schoenebeck 563 case playback_state_init:
609     this->PlaybackState = playback_state_ram; // we always start playback from RAM cache and switch then to disk if needed
610     // no break - continue with playback_state_ram
611    
612 schoenebeck 319 case playback_state_ram: {
613     if (RAMLoop) SYNTHESIS_MODE_SET_LOOP(SynthesisMode, true); // enable looping
614 schoenebeck 80
615 schoenebeck 319 // render current fragment
616     Synthesize(Samples, (sample_t*) pSample->GetCache().pStart, Delay);
617 schoenebeck 53
618     if (DiskVoice) {
619     // check if we reached the allowed limit of the sample RAM cache
620     if (Pos > MaxRAMPos) {
621     dmsg(5,("Voice: switching to disk playback (Pos=%f)\n", Pos));
622     this->PlaybackState = playback_state_disk;
623     }
624     }
625     else if (Pos >= pSample->GetCache().Size / pSample->FrameSize) {
626     this->PlaybackState = playback_state_end;
627     }
628     }
629     break;
630    
631     case playback_state_disk: {
632     if (!DiskStreamRef.pStream) {
633     // check if the disk thread created our ordered disk stream in the meantime
634     DiskStreamRef.pStream = pDiskThread->AskForCreatedStream(DiskStreamRef.OrderID);
635     if (!DiskStreamRef.pStream) {
636     std::cout << stderr << "Disk stream not available in time!" << std::endl << std::flush;
637 schoenebeck 239 KillImmediately();
638 schoenebeck 53 return;
639     }
640 schoenebeck 319 DiskStreamRef.pStream->IncrementReadPos(pSample->Channels * (int(Pos) - MaxRAMPos));
641     Pos -= int(Pos);
642 schoenebeck 330 RealSampleWordsLeftToRead = -1; // -1 means no silence has been added yet
643 schoenebeck 53 }
644    
645 schoenebeck 323 const int sampleWordsLeftToRead = DiskStreamRef.pStream->GetReadSpace();
646    
647 schoenebeck 53 // add silence sample at the end if we reached the end of the stream (for the interpolator)
648 schoenebeck 323 if (DiskStreamRef.State == Stream::state_end) {
649 schoenebeck 554 const int maxSampleWordsPerCycle = (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH) * pSample->Channels + 6; // +6 for the interpolator algorithm
650 schoenebeck 323 if (sampleWordsLeftToRead <= maxSampleWordsPerCycle) {
651 schoenebeck 330 // remember how many sample words there are before any silence has been added
652     if (RealSampleWordsLeftToRead < 0) RealSampleWordsLeftToRead = sampleWordsLeftToRead;
653 schoenebeck 323 DiskStreamRef.pStream->WriteSilence(maxSampleWordsPerCycle - sampleWordsLeftToRead);
654     }
655 schoenebeck 53 }
656    
657     sample_t* ptr = DiskStreamRef.pStream->GetReadPtr(); // get the current read_ptr within the ringbuffer where we read the samples from
658 schoenebeck 319
659     // render current audio fragment
660     Synthesize(Samples, ptr, Delay);
661    
662 schoenebeck 323 const int iPos = (int) Pos;
663     const int readSampleWords = iPos * pSample->Channels; // amount of sample words actually been read
664     DiskStreamRef.pStream->IncrementReadPos(readSampleWords);
665     Pos -= iPos; // just keep fractional part of Pos
666    
667     // change state of voice to 'end' if we really reached the end of the sample data
668 schoenebeck 330 if (RealSampleWordsLeftToRead >= 0) {
669     RealSampleWordsLeftToRead -= readSampleWords;
670     if (RealSampleWordsLeftToRead <= 0) this->PlaybackState = playback_state_end;
671     }
672 schoenebeck 53 }
673     break;
674    
675     case playback_state_end:
676 schoenebeck 285 std::cerr << "gig::Voice::Render(): entered with playback_state_end, this is a bug!\n" << std::flush;
677 schoenebeck 53 break;
678     }
679    
680 schoenebeck 236 // Reset synthesis event lists (except VCO, as VCO events apply channel wide currently)
681 schoenebeck 460 pEngineChannel->pSynthesisEvents[Event::destination_vca]->clear();
682     pEngineChannel->pSynthesisEvents[Event::destination_vcfc]->clear();
683     pEngineChannel->pSynthesisEvents[Event::destination_vcfr]->clear();
684 schoenebeck 53
685     // Reset delay
686     Delay = 0;
687    
688 schoenebeck 271 itTriggerEvent = Pool<Event>::Iterator();
689 schoenebeck 53
690 schoenebeck 285 // If sample stream or release stage finished, kill the voice
691     if (PlaybackState == playback_state_end || pEG1->GetStage() == EGADSR::stage_end) KillImmediately();
692 schoenebeck 53 }
693    
694     /**
695     * Resets voice variables. Should only be called if rendering process is
696     * suspended / not running.
697     */
698     void Voice::Reset() {
699     pLFO1->Reset();
700     pLFO2->Reset();
701     pLFO3->Reset();
702 schoenebeck 319 FilterLeft.Reset();
703     FilterRight.Reset();
704 schoenebeck 53 DiskStreamRef.pStream = NULL;
705     DiskStreamRef.hStream = 0;
706     DiskStreamRef.State = Stream::state_unused;
707     DiskStreamRef.OrderID = 0;
708 schoenebeck 285 PlaybackState = playback_state_end;
709     itTriggerEvent = Pool<Event>::Iterator();
710     itKillEvent = Pool<Event>::Iterator();
711 schoenebeck 53 }
712    
713     /**
714     * Process the control change event lists of the engine for the current
715     * audio fragment. Event values will be applied to the synthesis parameter
716     * matrix.
717     *
718     * @param Samples - number of samples to be rendered in this audio fragment cycle
719     */
720     void Voice::ProcessEvents(uint Samples) {
721    
722     // dispatch control change events
723 schoenebeck 460 RTList<Event>::Iterator itCCEvent = pEngineChannel->pCCEvents->first();
724 schoenebeck 53 if (Delay) { // skip events that happened before this voice was triggered
725 schoenebeck 271 while (itCCEvent && itCCEvent->FragmentPos() <= Delay) ++itCCEvent;
726 schoenebeck 53 }
727 schoenebeck 271 while (itCCEvent) {
728     if (itCCEvent->Param.CC.Controller) { // if valid MIDI controller
729     if (itCCEvent->Param.CC.Controller == VCFCutoffCtrl.controller) {
730 schoenebeck 460 *pEngineChannel->pSynthesisEvents[Event::destination_vcfc]->allocAppend() = *itCCEvent;
731 schoenebeck 53 }
732 schoenebeck 271 if (itCCEvent->Param.CC.Controller == VCFResonanceCtrl.controller) {
733 schoenebeck 460 *pEngineChannel->pSynthesisEvents[Event::destination_vcfr]->allocAppend() = *itCCEvent;
734 schoenebeck 53 }
735 schoenebeck 271 if (itCCEvent->Param.CC.Controller == pLFO1->ExtController) {
736     pLFO1->SendEvent(itCCEvent);
737 schoenebeck 53 }
738 schoenebeck 271 if (itCCEvent->Param.CC.Controller == pLFO2->ExtController) {
739     pLFO2->SendEvent(itCCEvent);
740 schoenebeck 53 }
741 schoenebeck 271 if (itCCEvent->Param.CC.Controller == pLFO3->ExtController) {
742     pLFO3->SendEvent(itCCEvent);
743 schoenebeck 53 }
744 schoenebeck 236 if (pDimRgn->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&
745 schoenebeck 271 itCCEvent->Param.CC.Controller == pDimRgn->AttenuationController.controller_number) { // if crossfade event
746 schoenebeck 460 *pEngineChannel->pSynthesisEvents[Event::destination_vca]->allocAppend() = *itCCEvent;
747 schoenebeck 236 }
748 schoenebeck 53 }
749    
750 schoenebeck 271 ++itCCEvent;
751 schoenebeck 53 }
752    
753    
754     // process pitch events
755     {
756 schoenebeck 460 RTList<Event>* pVCOEventList = pEngineChannel->pSynthesisEvents[Event::destination_vco];
757 schoenebeck 271 RTList<Event>::Iterator itVCOEvent = pVCOEventList->first();
758 schoenebeck 53 if (Delay) { // skip events that happened before this voice was triggered
759 schoenebeck 271 while (itVCOEvent && itVCOEvent->FragmentPos() <= Delay) ++itVCOEvent;
760 schoenebeck 53 }
761     // apply old pitchbend value until first pitch event occurs
762     if (this->PitchBend != 1.0) {
763 schoenebeck 271 uint end = (itVCOEvent) ? itVCOEvent->FragmentPos() : Samples;
764 schoenebeck 53 for (uint i = Delay; i < end; i++) {
765     pEngine->pSynthesisParameters[Event::destination_vco][i] *= this->PitchBend;
766     }
767     }
768     float pitch;
769 schoenebeck 271 while (itVCOEvent) {
770     RTList<Event>::Iterator itNextVCOEvent = itVCOEvent;
771     ++itNextVCOEvent;
772 schoenebeck 53
773     // calculate the influence length of this event (in sample points)
774 schoenebeck 271 uint end = (itNextVCOEvent) ? itNextVCOEvent->FragmentPos() : Samples;
775 schoenebeck 53
776 schoenebeck 271 pitch = RTMath::CentsToFreqRatio(((double) itVCOEvent->Param.Pitch.Pitch / 8192.0) * 200.0); // +-two semitones = +-200 cents
777 schoenebeck 53
778     // apply pitch value to the pitch parameter sequence
779 schoenebeck 271 for (uint i = itVCOEvent->FragmentPos(); i < end; i++) {
780 schoenebeck 53 pEngine->pSynthesisParameters[Event::destination_vco][i] *= pitch;
781     }
782    
783 schoenebeck 271 itVCOEvent = itNextVCOEvent;
784 schoenebeck 53 }
785 schoenebeck 319 if (!pVCOEventList->isEmpty()) {
786     this->PitchBend = pitch;
787     SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
788     SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
789     }
790 schoenebeck 53 }
791    
792 schoenebeck 236 // process volume / attenuation events (TODO: we only handle and _expect_ crossfade events here ATM !)
793     {
794 schoenebeck 460 RTList<Event>* pVCAEventList = pEngineChannel->pSynthesisEvents[Event::destination_vca];
795 schoenebeck 271 RTList<Event>::Iterator itVCAEvent = pVCAEventList->first();
796 schoenebeck 236 if (Delay) { // skip events that happened before this voice was triggered
797 schoenebeck 271 while (itVCAEvent && itVCAEvent->FragmentPos() <= Delay) ++itVCAEvent;
798 schoenebeck 236 }
799     float crossfadevolume;
800 schoenebeck 271 while (itVCAEvent) {
801     RTList<Event>::Iterator itNextVCAEvent = itVCAEvent;
802     ++itNextVCAEvent;
803 schoenebeck 53
804 schoenebeck 236 // calculate the influence length of this event (in sample points)
805 schoenebeck 271 uint end = (itNextVCAEvent) ? itNextVCAEvent->FragmentPos() : Samples;
806 schoenebeck 236
807 schoenebeck 271 crossfadevolume = CrossfadeAttenuation(itVCAEvent->Param.CC.Value);
808 schoenebeck 236
809 schoenebeck 411 float effective_volume = crossfadevolume * this->Volume * pEngineChannel->GlobalVolume;
810 schoenebeck 236
811     // apply volume value to the volume parameter sequence
812 schoenebeck 271 for (uint i = itVCAEvent->FragmentPos(); i < end; i++) {
813 schoenebeck 236 pEngine->pSynthesisParameters[Event::destination_vca][i] = effective_volume;
814     }
815    
816 schoenebeck 271 itVCAEvent = itNextVCAEvent;
817 schoenebeck 236 }
818 schoenebeck 271 if (!pVCAEventList->isEmpty()) this->CrossfadeVolume = crossfadevolume;
819 schoenebeck 236 }
820    
821 schoenebeck 53 // process filter cutoff events
822     {
823 schoenebeck 460 RTList<Event>* pCutoffEventList = pEngineChannel->pSynthesisEvents[Event::destination_vcfc];
824 schoenebeck 271 RTList<Event>::Iterator itCutoffEvent = pCutoffEventList->first();
825 schoenebeck 53 if (Delay) { // skip events that happened before this voice was triggered
826 schoenebeck 271 while (itCutoffEvent && itCutoffEvent->FragmentPos() <= Delay) ++itCutoffEvent;
827 schoenebeck 53 }
828     float cutoff;
829 schoenebeck 271 while (itCutoffEvent) {
830     RTList<Event>::Iterator itNextCutoffEvent = itCutoffEvent;
831     ++itNextCutoffEvent;
832 schoenebeck 53
833     // calculate the influence length of this event (in sample points)
834 schoenebeck 271 uint end = (itNextCutoffEvent) ? itNextCutoffEvent->FragmentPos() : Samples;
835 schoenebeck 53
836 schoenebeck 554 cutoff = exp((float) itCutoffEvent->Param.CC.Value * 0.00787402f * FILTER_CUTOFF_COEFF) * CONFIG_FILTER_CUTOFF_MAX - CONFIG_FILTER_CUTOFF_MIN;
837 schoenebeck 53
838     // apply cutoff frequency to the cutoff parameter sequence
839 schoenebeck 271 for (uint i = itCutoffEvent->FragmentPos(); i < end; i++) {
840 schoenebeck 53 pEngine->pSynthesisParameters[Event::destination_vcfc][i] = cutoff;
841     }
842    
843 schoenebeck 271 itCutoffEvent = itNextCutoffEvent;
844 schoenebeck 53 }
845 schoenebeck 271 if (!pCutoffEventList->isEmpty()) VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of parameter matrix next time
846 schoenebeck 53 }
847    
848     // process filter resonance events
849     {
850 schoenebeck 460 RTList<Event>* pResonanceEventList = pEngineChannel->pSynthesisEvents[Event::destination_vcfr];
851 schoenebeck 271 RTList<Event>::Iterator itResonanceEvent = pResonanceEventList->first();
852 schoenebeck 53 if (Delay) { // skip events that happened before this voice was triggered
853 schoenebeck 271 while (itResonanceEvent && itResonanceEvent->FragmentPos() <= Delay) ++itResonanceEvent;
854 schoenebeck 53 }
855 schoenebeck 271 while (itResonanceEvent) {
856     RTList<Event>::Iterator itNextResonanceEvent = itResonanceEvent;
857     ++itNextResonanceEvent;
858 schoenebeck 53
859     // calculate the influence length of this event (in sample points)
860 schoenebeck 271 uint end = (itNextResonanceEvent) ? itNextResonanceEvent->FragmentPos() : Samples;
861 schoenebeck 53
862     // convert absolute controller value to differential
863 schoenebeck 271 int ctrldelta = itResonanceEvent->Param.CC.Value - VCFResonanceCtrl.value;
864     VCFResonanceCtrl.value = itResonanceEvent->Param.CC.Value;
865 schoenebeck 53
866     float resonancedelta = (float) ctrldelta * 0.00787f; // 0.0..1.0
867    
868     // apply cutoff frequency to the cutoff parameter sequence
869 schoenebeck 271 for (uint i = itResonanceEvent->FragmentPos(); i < end; i++) {
870 schoenebeck 53 pEngine->pSynthesisParameters[Event::destination_vcfr][i] += resonancedelta;
871     }
872    
873 schoenebeck 271 itResonanceEvent = itNextResonanceEvent;
874 schoenebeck 53 }
875 schoenebeck 271 if (!pResonanceEventList->isEmpty()) VCFResonanceCtrl.fvalue = pResonanceEventList->last()->Param.CC.Value * 0.00787f; // needed for initialization of parameter matrix next time
876 schoenebeck 53 }
877     }
878    
879     /**
880 schoenebeck 80 * Calculate all necessary, final biquad filter parameters.
881     *
882     * @param Samples - number of samples to be rendered in this audio fragment cycle
883     */
884     void Voice::CalculateBiquadParameters(uint Samples) {
885     biquad_param_t bqbase;
886     biquad_param_t bqmain;
887     float prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][0];
888     float prev_res = pEngine->pSynthesisParameters[Event::destination_vcfr][0];
889 schoenebeck 554 FilterLeft.SetParameters( &bqbase, &bqmain, prev_cutoff + CONFIG_FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
890     FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff + CONFIG_FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
891 schoenebeck 80 pEngine->pBasicFilterParameters[0] = bqbase;
892     pEngine->pMainFilterParameters[0] = bqmain;
893    
894     float* bq;
895     for (int i = 1; i < Samples; i++) {
896     // recalculate biquad parameters if cutoff or resonance differ from previous sample point
897 schoenebeck 319 if (!(i & FILTER_UPDATE_MASK)) {
898     if (pEngine->pSynthesisParameters[Event::destination_vcfr][i] != prev_res ||
899     pEngine->pSynthesisParameters[Event::destination_vcfc][i] != prev_cutoff)
900     {
901     prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][i];
902     prev_res = pEngine->pSynthesisParameters[Event::destination_vcfr][i];
903 schoenebeck 554 FilterLeft.SetParameters( &bqbase, &bqmain, prev_cutoff + CONFIG_FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
904     FilterRight.SetParameters(&bqbase, &bqmain, prev_cutoff + CONFIG_FILTER_CUTOFF_MIN, prev_res, pEngine->SampleRate);
905 schoenebeck 319 }
906 schoenebeck 80 }
907    
908     //same as 'pEngine->pBasicFilterParameters[i] = bqbase;'
909     bq = (float*) &pEngine->pBasicFilterParameters[i];
910 senkov 324 bq[0] = bqbase.b0;
911     bq[1] = bqbase.b1;
912     bq[2] = bqbase.b2;
913     bq[3] = bqbase.a1;
914     bq[4] = bqbase.a2;
915 schoenebeck 80
916     // same as 'pEngine->pMainFilterParameters[i] = bqmain;'
917     bq = (float*) &pEngine->pMainFilterParameters[i];
918 senkov 324 bq[0] = bqmain.b0;
919     bq[1] = bqmain.b1;
920     bq[2] = bqmain.b2;
921     bq[3] = bqmain.a1;
922     bq[4] = bqmain.a2;
923 schoenebeck 80 }
924     }
925    
926     /**
927 schoenebeck 319 * Synthesizes the current audio fragment for this voice.
928 schoenebeck 53 *
929     * @param Samples - number of sample points to be rendered in this audio
930     * fragment cycle
931     * @param pSrc - pointer to input sample data
932     * @param Skip - number of sample points to skip in output buffer
933     */
934 senkov 325 void Voice::Synthesize(uint Samples, sample_t* pSrc, uint Skip) {
935     RunSynthesisFunction(SynthesisMode, *this, Samples, pSrc, Skip);
936 schoenebeck 53 }
937    
938     /**
939 schoenebeck 239 * Immediately kill the voice. This method should not be used to kill
940     * a normal, active voice, because it doesn't take care of things like
941     * fading down the volume level to avoid clicks and regular processing
942     * until the kill event actually occured!
943     *
944     * @see Kill()
945 schoenebeck 53 */
946 schoenebeck 239 void Voice::KillImmediately() {
947 schoenebeck 53 if (DiskVoice && DiskStreamRef.State != Stream::state_unused) {
948     pDiskThread->OrderDeletionOfStream(&DiskStreamRef);
949     }
950     Reset();
951     }
952    
953 schoenebeck 239 /**
954     * Kill the voice in regular sense. Let the voice render audio until
955     * the kill event actually occured and then fade down the volume level
956     * very quickly and let the voice die finally. Unlike a normal release
957     * of a voice, a kill process cannot be cancalled and is therefore
958     * usually used for voice stealing and key group conflicts.
959     *
960 schoenebeck 271 * @param itKillEvent - event which caused the voice to be killed
961 schoenebeck 239 */
962 schoenebeck 271 void Voice::Kill(Pool<Event>::Iterator& itKillEvent) {
963 schoenebeck 554 #if CONFIG_DEVMODE
964 schoenebeck 287 if (!itKillEvent) dmsg(1,("gig::Voice::Kill(): ERROR, !itKillEvent !!!\n"));
965     if (itKillEvent && !itKillEvent.isValid()) dmsg(1,("gig::Voice::Kill(): ERROR, itKillEvent invalid !!!\n"));
966 schoenebeck 554 #endif // CONFIG_DEVMODE
967 schoenebeck 287
968 schoenebeck 271 if (itTriggerEvent && itKillEvent->FragmentPos() <= itTriggerEvent->FragmentPos()) return;
969     this->itKillEvent = itKillEvent;
970 schoenebeck 239 }
971    
972 schoenebeck 53 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC