/[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 617 - (hide annotations) (download)
Wed Jun 8 21:00:06 2005 UTC (18 years, 9 months ago) by schoenebeck
File size: 52463 byte(s)
* hand-crafted assembly optimization code can be disabled with
  './configure --disable-asm' (definitely not recommended)

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

  ViewVC Help
Powered by ViewVC