/[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 1895 - (hide annotations) (download)
Sun May 3 12:15:40 2009 UTC (9 years, 3 months ago) by persson
File size: 51127 byte(s)
* fixes for using large audio device buffers
* VST: added support for sample rate and buffer size changes
* VST: close editor (Fantasia) when the VST is removed
* minor fix in configure for mmsystem.h detection on MinGW
* removed warnings from gcc 4.4 and valgrind

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

  ViewVC Help
Powered by ViewVC