/[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 877 - (hide annotations) (download)
Sun Jun 25 13:54:17 2006 UTC (17 years, 9 months ago) by persson
File size: 47736 byte(s)
* new filter implementation, which is more accurate and supports all
  filter types including bandreject and lowpass turbo

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

  ViewVC Help
Powered by ViewVC