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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 669 by schoenebeck, Tue Jun 21 13:33:19 2005 UTC revision 696 by persson, Sat Jul 16 19:37:52 2005 UTC
# Line 249  namespace LinuxSampler { namespace gig { Line 249  namespace LinuxSampler { namespace gig {
249              }              }
250              if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;              if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;
251    
252              // calculate influence of EG1 controller on EG1's parameters (TODO: needs to be fine tuned)              // calculate influence of EG1 controller on EG1's parameters
253              double eg1attack  = (pDimRgn->EG1ControllerAttackInfluence)  ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerAttackInfluence)  * eg1controllervalue : 0.0;              // (eg1attack is different from the others)
254              double eg1decay   = (pDimRgn->EG1ControllerDecayInfluence)   ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerDecayInfluence)   * eg1controllervalue : 0.0;              double eg1attack  = (pDimRgn->EG1ControllerAttackInfluence)  ?
255              double eg1release = (pDimRgn->EG1ControllerReleaseInfluence) ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerReleaseInfluence) * eg1controllervalue : 0.0;                  1 + 0.031 * (double) (pDimRgn->EG1ControllerAttackInfluence == 1 ?
256                                          1 : 1 << pDimRgn->EG1ControllerAttackInfluence) * eg1controllervalue : 1.0;
257                double eg1decay   = (pDimRgn->EG1ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerDecayInfluence)   * eg1controllervalue : 1.0;
258                double eg1release = (pDimRgn->EG1ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerReleaseInfluence) * eg1controllervalue : 1.0;
259    
260              pEG1->Trigger(pDimRgn->EG1PreAttack,              pEG1->Trigger(pDimRgn->EG1PreAttack,
261                            pDimRgn->EG1Attack + eg1attack,                            pDimRgn->EG1Attack * eg1attack,
262                            pDimRgn->EG1Hold,                            pDimRgn->EG1Hold,
263                            pSample->LoopStart,                            pSample->LoopStart,
264                            (pDimRgn->EG1Decay1 + eg1decay) * velrelease,                            pDimRgn->EG1Decay1 * eg1decay * velrelease,
265                            (pDimRgn->EG1Decay2 + eg1decay) * velrelease,                            pDimRgn->EG1Decay2 * eg1decay * velrelease,
266                            pDimRgn->EG1InfiniteSustain,                            pDimRgn->EG1InfiniteSustain,
267                            pDimRgn->EG1Sustain,                            pDimRgn->EG1Sustain,
268                            (pDimRgn->EG1Release + eg1release) * velrelease,                            pDimRgn->EG1Release * eg1release * velrelease,
269                            // the SSE synthesis implementation requires                            // the SSE synthesis implementation requires
270                            // the vca start to be 16 byte aligned                            // the vca start to be 16 byte aligned
271                            SYNTHESIS_MODE_GET_IMPLEMENTATION(SynthesisMode) ?                            SYNTHESIS_MODE_GET_IMPLEMENTATION(SynthesisMode) ?
# Line 291  namespace LinuxSampler { namespace gig { Line 294  namespace LinuxSampler { namespace gig {
294              }              }
295              if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;              if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;
296    
297              // calculate influence of EG2 controller on EG2's parameters (TODO: needs to be fine tuned)              // calculate influence of EG2 controller on EG2's parameters
298              double eg2attack  = (pDimRgn->EG2ControllerAttackInfluence)  ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerAttackInfluence)  * eg2controllervalue : 0.0;              double eg2attack  = (pDimRgn->EG2ControllerAttackInfluence)  ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerAttackInfluence)  * eg2controllervalue : 1.0;
299              double eg2decay   = (pDimRgn->EG2ControllerDecayInfluence)   ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerDecayInfluence)   * eg2controllervalue : 0.0;              double eg2decay   = (pDimRgn->EG2ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerDecayInfluence)   * eg2controllervalue : 1.0;
300              double eg2release = (pDimRgn->EG2ControllerReleaseInfluence) ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerReleaseInfluence) * eg2controllervalue : 0.0;              double eg2release = (pDimRgn->EG2ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerReleaseInfluence) * eg2controllervalue : 1.0;
301    
302              pEG2->Trigger(pDimRgn->EG2PreAttack,              pEG2->Trigger(pDimRgn->EG2PreAttack,
303                            pDimRgn->EG2Attack + eg2attack,                            pDimRgn->EG2Attack * eg2attack,
304                            false,                            false,
305                            pSample->LoopStart,                            pSample->LoopStart,
306                            (pDimRgn->EG2Decay1 + eg2decay) * velrelease,                            pDimRgn->EG2Decay1 * eg2decay * velrelease,
307                            (pDimRgn->EG2Decay2 + eg2decay) * velrelease,                            pDimRgn->EG2Decay2 * eg2decay * velrelease,
308                            pDimRgn->EG2InfiniteSustain,                            pDimRgn->EG2InfiniteSustain,
309                            pDimRgn->EG2Sustain,                            pDimRgn->EG2Sustain,
310                            (pDimRgn->EG2Release + eg2release) * velrelease,                            pDimRgn->EG2Release * eg2release * velrelease,
311                            Delay,                            Delay,
312                            velocityAttenuation);                            velocityAttenuation);
313          }          }
# Line 324  namespace LinuxSampler { namespace gig { Line 327  namespace LinuxSampler { namespace gig {
327                  case ::gig::lfo1_ctrl_internal:                  case ::gig::lfo1_ctrl_internal:
328                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
329                      pLFO1->ExtController = 0; // no external controller                      pLFO1->ExtController = 0; // no external controller
330                        bLFO1Enabled         = (lfo1_internal_depth > 0);
331                      break;                      break;
332                  case ::gig::lfo1_ctrl_modwheel:                  case ::gig::lfo1_ctrl_modwheel:
333                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
334                      pLFO1->ExtController = 1; // MIDI controller 1                      pLFO1->ExtController = 1; // MIDI controller 1
335                        bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);
336                      break;                      break;
337                  case ::gig::lfo1_ctrl_breath:                  case ::gig::lfo1_ctrl_breath:
338                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
339                      pLFO1->ExtController = 2; // MIDI controller 2                      pLFO1->ExtController = 2; // MIDI controller 2
340                        bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);
341                      break;                      break;
342                  case ::gig::lfo1_ctrl_internal_modwheel:                  case ::gig::lfo1_ctrl_internal_modwheel:
343                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
344                      pLFO1->ExtController = 1; // MIDI controller 1                      pLFO1->ExtController = 1; // MIDI controller 1
345                        bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
346                      break;                      break;
347                  case ::gig::lfo1_ctrl_internal_breath:                  case ::gig::lfo1_ctrl_internal_breath:
348                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;                      lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;
349                      pLFO1->ExtController = 2; // MIDI controller 2                      pLFO1->ExtController = 2; // MIDI controller 2
350                        bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);
351                      break;                      break;
352                  default:                  default:
353                      lfo1_internal_depth  = 0;                      lfo1_internal_depth  = 0;
354                      pLFO1->ExtController = 0; // no external controller                      pLFO1->ExtController = 0; // no external controller
355                        bLFO1Enabled         = false;
356              }              }
357              pLFO1->Trigger(pDimRgn->LFO1Frequency,              if (bLFO1Enabled) pLFO1->Trigger(pDimRgn->LFO1Frequency,
358                            lfo1_internal_depth,                                               lfo1_internal_depth,
359                            pDimRgn->LFO1ControlDepth,                                               pDimRgn->LFO1ControlDepth,
360                            pEngineChannel->ControllerTable[pLFO1->ExtController],                                               pEngineChannel->ControllerTable[pLFO1->ExtController],
361                            pDimRgn->LFO1FlipPhase,                                               pDimRgn->LFO1FlipPhase,
362                            pEngine->SampleRate,                                               pEngine->SampleRate,
363                            Delay);                                               Delay);
364          }          }
365    
366    
# Line 362  namespace LinuxSampler { namespace gig { Line 371  namespace LinuxSampler { namespace gig {
371                  case ::gig::lfo2_ctrl_internal:                  case ::gig::lfo2_ctrl_internal:
372                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
373                      pLFO2->ExtController = 0; // no external controller                      pLFO2->ExtController = 0; // no external controller
374                        bLFO2Enabled         = (lfo2_internal_depth > 0);
375                      break;                      break;
376                  case ::gig::lfo2_ctrl_modwheel:                  case ::gig::lfo2_ctrl_modwheel:
377                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
378                      pLFO2->ExtController = 1; // MIDI controller 1                      pLFO2->ExtController = 1; // MIDI controller 1
379                        bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);
380                      break;                      break;
381                  case ::gig::lfo2_ctrl_foot:                  case ::gig::lfo2_ctrl_foot:
382                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
383                      pLFO2->ExtController = 4; // MIDI controller 4                      pLFO2->ExtController = 4; // MIDI controller 4
384                        bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);
385                      break;                      break;
386                  case ::gig::lfo2_ctrl_internal_modwheel:                  case ::gig::lfo2_ctrl_internal_modwheel:
387                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
388                      pLFO2->ExtController = 1; // MIDI controller 1                      pLFO2->ExtController = 1; // MIDI controller 1
389                        bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
390                      break;                      break;
391                  case ::gig::lfo2_ctrl_internal_foot:                  case ::gig::lfo2_ctrl_internal_foot:
392                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;                      lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;
393                      pLFO2->ExtController = 4; // MIDI controller 4                      pLFO2->ExtController = 4; // MIDI controller 4
394                        bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);
395                      break;                      break;
396                  default:                  default:
397                      lfo2_internal_depth  = 0;                      lfo2_internal_depth  = 0;
398                      pLFO2->ExtController = 0; // no external controller                      pLFO2->ExtController = 0; // no external controller
399                        bLFO2Enabled         = false;
400              }              }
401              pLFO2->Trigger(pDimRgn->LFO2Frequency,              if (bLFO2Enabled) pLFO2->Trigger(pDimRgn->LFO2Frequency,
402                            lfo2_internal_depth,                                               lfo2_internal_depth,
403                            pDimRgn->LFO2ControlDepth,                                               pDimRgn->LFO2ControlDepth,
404                            pEngineChannel->ControllerTable[pLFO2->ExtController],                                               pEngineChannel->ControllerTable[pLFO2->ExtController],
405                            pDimRgn->LFO2FlipPhase,                                               pDimRgn->LFO2FlipPhase,
406                            pEngine->SampleRate,                                               pEngine->SampleRate,
407                            Delay);                                               Delay);
408          }          }
409    
410    
# Line 400  namespace LinuxSampler { namespace gig { Line 415  namespace LinuxSampler { namespace gig {
415                  case ::gig::lfo3_ctrl_internal:                  case ::gig::lfo3_ctrl_internal:
416                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
417                      pLFO3->ExtController = 0; // no external controller                      pLFO3->ExtController = 0; // no external controller
418                        bLFO3Enabled         = (lfo3_internal_depth > 0);
419                      break;                      break;
420                  case ::gig::lfo3_ctrl_modwheel:                  case ::gig::lfo3_ctrl_modwheel:
421                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
422                      pLFO3->ExtController = 1; // MIDI controller 1                      pLFO3->ExtController = 1; // MIDI controller 1
423                        bLFO3Enabled         = (pDimRgn->LFO3ControlDepth > 0);
424                      break;                      break;
425                  case ::gig::lfo3_ctrl_aftertouch:                  case ::gig::lfo3_ctrl_aftertouch:
426                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
427                      pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet                      pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet
428                        bLFO3Enabled         = false; // see TODO comment in line above
429                      break;                      break;
430                  case ::gig::lfo3_ctrl_internal_modwheel:                  case ::gig::lfo3_ctrl_internal_modwheel:
431                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
432                      pLFO3->ExtController = 1; // MIDI controller 1                      pLFO3->ExtController = 1; // MIDI controller 1
433                        bLFO3Enabled         = (lfo3_internal_depth > 0 || pDimRgn->LFO3ControlDepth > 0);
434                      break;                      break;
435                  case ::gig::lfo3_ctrl_internal_aftertouch:                  case ::gig::lfo3_ctrl_internal_aftertouch:
436                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;
437                      pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet                      pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet
438                        bLFO3Enabled         = (lfo3_internal_depth > 0 /*|| pDimRgn->LFO3ControlDepth > 0*/); // see TODO comment in line above
439                      break;                      break;
440                  default:                  default:
441                      lfo3_internal_depth  = 0;                      lfo3_internal_depth  = 0;
442                      pLFO3->ExtController = 0; // no external controller                      pLFO3->ExtController = 0; // no external controller
443                        bLFO3Enabled         = false;
444              }              }
445              pLFO3->Trigger(pDimRgn->LFO3Frequency,              if (bLFO3Enabled) pLFO3->Trigger(pDimRgn->LFO3Frequency,
446                            lfo3_internal_depth,                                               lfo3_internal_depth,
447                            pDimRgn->LFO3ControlDepth,                                               pDimRgn->LFO3ControlDepth,
448                            pEngineChannel->ControllerTable[pLFO3->ExtController],                                               pEngineChannel->ControllerTable[pLFO3->ExtController],
449                            false,                                               false,
450                            pEngine->SampleRate,                                               pEngine->SampleRate,
451                            Delay);                                               Delay);
452          }          }
453    
454    
# Line 570  namespace LinuxSampler { namespace gig { Line 591  namespace LinuxSampler { namespace gig {
591              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
592              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
593          }          }
594          pLFO1->Process(Samples);          if (bLFO1Enabled) pLFO1->Process(Samples);
595          pLFO2->Process(Samples);          if (bLFO2Enabled) pLFO2->Process(Samples);
596          if (pLFO3->Process(Samples)) { // if pitch LFO modulation is active          if (bLFO3Enabled) {
597              SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);              if (pLFO3->Process(Samples)) { // if pitch LFO modulation is active
598              SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);                  SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, true);
599                    SYNTHESIS_MODE_SET_CONSTPITCH(SynthesisMode, false);
600                }
601          }          }
602    
603          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))          if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode))
Legend:
Removed from v.669  
changed lines
  Added in v.696
  ViewVC Help
Powered by ViewVC