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