/[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 783 - (show annotations) (download)
Sun Oct 2 14:40:52 2005 UTC (18 years, 5 months ago) by persson
File size: 44798 byte(s)
* EG fixes: the length of "attack hold" stage was wrong. Release stage
  can now start before attack stage ends. Cancel release didn't work
  when sustain was zero.

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

  ViewVC Help
Powered by ViewVC