/[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 1321 - (hide annotations) (download)
Tue Sep 4 01:12:49 2007 UTC (11 years, 1 month ago) by schoenebeck
File size: 49298 byte(s)
* added highly experimental code for synchronizing instrument editors
  hosted in the sampler's process to safely edit instruments while playing
  without a crash (hopefully) by either suspending single regions wherever
  possible or - if unavoidable - whole engine(s)
* disk thread: queue sizes are now proportional to CONFIG_MAX_STREAMS
  instead of fix values
* removed legacy Makefiles in meanwhile deleted src/lib directory and its
  subdirectories
* bumped version to 0.4.0.7cvs

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

  ViewVC Help
Powered by ViewVC