/[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 1923 - (show annotations) (download)
Sat Jun 27 16:55:41 2009 UTC (10 years, 9 months ago) by persson
File size: 51138 byte(s)
* fixed crash happening when a pitch bend event arrived at the same
  time a new instrument was loading
* fixed building with sqlite installed in a non-standard directory

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

  ViewVC Help
Powered by ViewVC