/[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 799 - (hide annotations) (download)
Sat Nov 5 10:59:37 2005 UTC (13 years, 1 month ago) by persson
File size: 44849 byte(s)
* Bug-fixes: pitch changes larger than one octave didn't work. Looped
  samples small enough to fit in RAM didn't work.

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

  ViewVC Help
Powered by ViewVC