/[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 830 - (show annotations) (download)
Sun Jan 15 18:23:11 2006 UTC (18 years, 2 months ago) by persson
File size: 46624 byte(s)
* added linear interpolation of volume modulation inside a
  subfragment; this prevents clicks during voice stealing. Can be
  switched off with the --disable-interpolate-volume configure option.

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

  ViewVC Help
Powered by ViewVC