/[svn]/linuxsampler/trunk/src/engines/gig/Voice.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/gig/Voice.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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

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

  ViewVC Help
Powered by ViewVC