/[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 791 - (show annotations) (download)
Sun Oct 16 14:50:20 2005 UTC (14 years, 5 months ago) by persson
File size: 44678 byte(s)
* Filter tuning: calculation of cutoff frequency and bandwidth
  improved. Removed use of "BasicBPFilter". Changed bandpass filter
  from constant peak to constant skirt. Use gig parameter Resonance if
  no resonance controller is set. Removed keyboard tracking influence
  on resonance.

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 // VCFVelocityScale in this case means Minimum cutoff
498 if (cvalue < pDimRgn->VCFVelocityScale) cvalue = pDimRgn->VCFVelocityScale;
499 }
500 else {
501 cvalue = pDimRgn->VCFCutoff;
502 }
503 cutoff *= float(cvalue) * 0.00787402f; // (1 / 127)
504 if (cutoff > 1.0) cutoff = 1.0;
505 cutoff = (cutoff < 0.5 ? cutoff * 4826 - 1 : cutoff * 5715 - 449);
506 if (cutoff < 1.0) cutoff = 1.0;
507
508 // calculate resonance
509 float resonance = (float) (VCFResonanceCtrl.controller ? VCFResonanceCtrl.value : pDimRgn->VCFResonance) * 0.00787f; // 0.0..1.0
510
511 VCFCutoffCtrl.fvalue = cutoff - 1.0;
512 VCFResonanceCtrl.fvalue = resonance;
513 }
514 else {
515 VCFCutoffCtrl.controller = 0;
516 VCFResonanceCtrl.controller = 0;
517 }
518
519 return 0; // success
520 }
521
522 /**
523 * Renders the audio data for this voice for the current audio fragment.
524 * The sample input data can either come from RAM (cached sample or sample
525 * part) or directly from disk. The output signal will be rendered by
526 * resampling / interpolation. If this voice is a disk streaming voice and
527 * the voice completely played back the cached RAM part of the sample, it
528 * will automatically switch to disk playback for the next RenderAudio()
529 * call.
530 *
531 * @param Samples - number of samples to be rendered in this audio fragment cycle
532 */
533 void Voice::Render(uint Samples) {
534
535 // select default values for synthesis mode bits
536 SYNTHESIS_MODE_SET_LOOP(SynthesisMode, false);
537
538 switch (this->PlaybackState) {
539
540 case playback_state_init:
541 this->PlaybackState = playback_state_ram; // we always start playback from RAM cache and switch then to disk if needed
542 // no break - continue with playback_state_ram
543
544 case playback_state_ram: {
545 if (RAMLoop) SYNTHESIS_MODE_SET_LOOP(SynthesisMode, true); // enable looping
546
547 // render current fragment
548 Synthesize(Samples, (sample_t*) pSample->GetCache().pStart, Delay);
549
550 if (DiskVoice) {
551 // check if we reached the allowed limit of the sample RAM cache
552 if (finalSynthesisParameters.dPos > MaxRAMPos) {
553 dmsg(5,("Voice: switching to disk playback (Pos=%f)\n", finalSynthesisParameters.dPos));
554 this->PlaybackState = playback_state_disk;
555 }
556 } else if (finalSynthesisParameters.dPos >= pSample->GetCache().Size / pSample->FrameSize) {
557 this->PlaybackState = playback_state_end;
558 }
559 }
560 break;
561
562 case playback_state_disk: {
563 if (!DiskStreamRef.pStream) {
564 // check if the disk thread created our ordered disk stream in the meantime
565 DiskStreamRef.pStream = pDiskThread->AskForCreatedStream(DiskStreamRef.OrderID);
566 if (!DiskStreamRef.pStream) {
567 std::cout << stderr << "Disk stream not available in time!" << std::endl << std::flush;
568 KillImmediately();
569 return;
570 }
571 DiskStreamRef.pStream->IncrementReadPos(pSample->Channels * (int(finalSynthesisParameters.dPos) - MaxRAMPos));
572 finalSynthesisParameters.dPos -= int(finalSynthesisParameters.dPos);
573 RealSampleWordsLeftToRead = -1; // -1 means no silence has been added yet
574 }
575
576 const int sampleWordsLeftToRead = DiskStreamRef.pStream->GetReadSpace();
577
578 // add silence sample at the end if we reached the end of the stream (for the interpolator)
579 if (DiskStreamRef.State == Stream::state_end) {
580 const int maxSampleWordsPerCycle = (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH) * pSample->Channels + 6; // +6 for the interpolator algorithm
581 if (sampleWordsLeftToRead <= maxSampleWordsPerCycle) {
582 // remember how many sample words there are before any silence has been added
583 if (RealSampleWordsLeftToRead < 0) RealSampleWordsLeftToRead = sampleWordsLeftToRead;
584 DiskStreamRef.pStream->WriteSilence(maxSampleWordsPerCycle - sampleWordsLeftToRead);
585 }
586 }
587
588 sample_t* ptr = DiskStreamRef.pStream->GetReadPtr(); // get the current read_ptr within the ringbuffer where we read the samples from
589
590 // render current audio fragment
591 Synthesize(Samples, ptr, Delay);
592
593 const int iPos = (int) finalSynthesisParameters.dPos;
594 const int readSampleWords = iPos * pSample->Channels; // amount of sample words actually been read
595 DiskStreamRef.pStream->IncrementReadPos(readSampleWords);
596 finalSynthesisParameters.dPos -= iPos; // just keep fractional part of playback position
597
598 // change state of voice to 'end' if we really reached the end of the sample data
599 if (RealSampleWordsLeftToRead >= 0) {
600 RealSampleWordsLeftToRead -= readSampleWords;
601 if (RealSampleWordsLeftToRead <= 0) this->PlaybackState = playback_state_end;
602 }
603 }
604 break;
605
606 case playback_state_end:
607 std::cerr << "gig::Voice::Render(): entered with playback_state_end, this is a bug!\n" << std::flush;
608 break;
609 }
610
611 // Reset delay
612 Delay = 0;
613
614 itTriggerEvent = Pool<Event>::Iterator();
615
616 // If sample stream or release stage finished, kill the voice
617 if (PlaybackState == playback_state_end || EG1.getSegmentType() == EGADSR::segment_end) KillImmediately();
618 }
619
620 /**
621 * Resets voice variables. Should only be called if rendering process is
622 * suspended / not running.
623 */
624 void Voice::Reset() {
625 finalSynthesisParameters.filterLeft.Reset();
626 finalSynthesisParameters.filterRight.Reset();
627 DiskStreamRef.pStream = NULL;
628 DiskStreamRef.hStream = 0;
629 DiskStreamRef.State = Stream::state_unused;
630 DiskStreamRef.OrderID = 0;
631 PlaybackState = playback_state_end;
632 itTriggerEvent = Pool<Event>::Iterator();
633 itKillEvent = Pool<Event>::Iterator();
634 }
635
636 /**
637 * Process given list of MIDI note on, note off and sustain pedal events
638 * for the given time.
639 *
640 * @param itEvent - iterator pointing to the next event to be processed
641 * @param End - youngest time stamp where processing should be stopped
642 */
643 void Voice::processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End) {
644 for (; itEvent && itEvent->FragmentPos() <= End; ++itEvent) {
645 if (itEvent->Type == Event::type_release) {
646 EG1.update(EGADSR::event_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
647 EG2.update(EGADSR::event_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
648 } else if (itEvent->Type == Event::type_cancel_release) {
649 EG1.update(EGADSR::event_cancel_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
650 EG2.update(EGADSR::event_cancel_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
651 }
652 }
653 }
654
655 /**
656 * Process given list of MIDI control change and pitch bend events for
657 * the given time.
658 *
659 * @param itEvent - iterator pointing to the next event to be processed
660 * @param End - youngest time stamp where processing should be stopped
661 */
662 void Voice::processCCEvents(RTList<Event>::Iterator& itEvent, uint End) {
663 for (; itEvent && itEvent->FragmentPos() <= End; ++itEvent) {
664 if (itEvent->Type == Event::type_control_change &&
665 itEvent->Param.CC.Controller) { // if (valid) MIDI control change event
666 if (itEvent->Param.CC.Controller == VCFCutoffCtrl.controller) {
667 processCutoffEvent(itEvent);
668 }
669 if (itEvent->Param.CC.Controller == VCFResonanceCtrl.controller) {
670 processResonanceEvent(itEvent);
671 }
672 if (itEvent->Param.CC.Controller == pLFO1->ExtController) {
673 pLFO1->update(itEvent->Param.CC.Value);
674 }
675 if (itEvent->Param.CC.Controller == pLFO2->ExtController) {
676 pLFO2->update(itEvent->Param.CC.Value);
677 }
678 if (itEvent->Param.CC.Controller == pLFO3->ExtController) {
679 pLFO3->update(itEvent->Param.CC.Value);
680 }
681 if (pDimRgn->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&
682 itEvent->Param.CC.Controller == pDimRgn->AttenuationController.controller_number) {
683 processCrossFadeEvent(itEvent);
684 }
685 } else if (itEvent->Type == Event::type_pitchbend) { // if pitch bend event
686 processPitchEvent(itEvent);
687 }
688 }
689 }
690
691 void Voice::processPitchEvent(RTList<Event>::Iterator& itEvent) {
692 const float pitch = RTMath::CentsToFreqRatio(((double) itEvent->Param.Pitch.Pitch / 8192.0) * 200.0); // +-two semitones = +-200 cents
693 finalSynthesisParameters.fFinalPitch *= pitch;
694 PitchBend = pitch;
695 }
696
697 void Voice::processCrossFadeEvent(RTList<Event>::Iterator& itEvent) {
698 CrossfadeVolume = CrossfadeAttenuation(itEvent->Param.CC.Value);
699 #if CONFIG_PROCESS_MUTED_CHANNELS
700 const float effectiveVolume = CrossfadeVolume * Volume * (pEngineChannel->GetMute() ? 0 : pEngineChannel->GlobalVolume);
701 #else
702 const float effectiveVolume = CrossfadeVolume * Volume * pEngineChannel->GlobalVolume;
703 #endif
704 fFinalVolume = effectiveVolume;
705 }
706
707 void Voice::processCutoffEvent(RTList<Event>::Iterator& itEvent) {
708 int ccvalue = itEvent->Param.CC.Value;
709 if (VCFCutoffCtrl.value == ccvalue) return;
710 VCFCutoffCtrl.value == ccvalue;
711 if (pDimRgn->VCFCutoffControllerInvert) ccvalue = 127 - ccvalue;
712 if (ccvalue < pDimRgn->VCFVelocityScale) ccvalue = pDimRgn->VCFVelocityScale;
713 float cutoff = CutoffBase * float(ccvalue) * 0.00787402f; // (1 / 127)
714 if (cutoff > 1.0) cutoff = 1.0;
715 cutoff = (cutoff < 0.5 ? cutoff * 4826 - 1 : cutoff * 5715 - 449);
716 if (cutoff < 1.0) cutoff = 1.0;
717
718 VCFCutoffCtrl.fvalue = cutoff - 1.0; // 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 + 1.0, fFinalResonance, pEngine->SampleRate);
806 finalSynthesisParameters.filterRight.SetParameters(fFinalCutoff + 1.0, 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