/[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 831 - (hide annotations) (download)
Sat Jan 28 16:55:30 2006 UTC (18 years, 2 months ago) by persson
File size: 46827 byte(s)
* fixed global pan (CC10) which hasn't been working for a while
* fine tuning of the curves for volume (CC7) and pan (CC10 and gig
  parameter)
* added support for the "attenuation controller threshold" gig
  parameter

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

  ViewVC Help
Powered by ViewVC