/[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 239 by schoenebeck, Sun Sep 12 14:48:19 2004 UTC revision 2015 by iliev, Sun Oct 25 22:22:52 2009 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6     *   Copyright (C) 2005 - 2009 Christian Schoenebeck                       *
7     *   Copyright (C) 2009 Grigor Iliev                                       *
8   *                                                                         *   *                                                                         *
9   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
10   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 20  Line 22 
22   *   MA  02111-1307  USA                                                   *   *   MA  02111-1307  USA                                                   *
23   ***************************************************************************/   ***************************************************************************/
24    
25  #include "EGADSR.h"  #include "../../common/Features.h"
26  #include "Manipulator.h"  #include "Synthesizer.h"
27    #include "Profiler.h"
28    #include "Engine.h"
29    #include "EngineChannel.h"
30    
31  #include "Voice.h"  #include "Voice.h"
32    
33  namespace LinuxSampler { namespace gig {  namespace LinuxSampler { namespace gig {
34    
     // TODO: no support for crossfades yet  
   
     const float Voice::FILTER_CUTOFF_COEFF(CalculateFilterCutoffCoeff());  
   
     const int Voice::FILTER_UPDATE_MASK(CalculateFilterUpdateMask());  
   
     float Voice::CalculateFilterCutoffCoeff() {  
         return log(FILTER_CUTOFF_MIN / FILTER_CUTOFF_MAX);  
     }  
   
     int Voice::CalculateFilterUpdateMask() {  
         if (FILTER_UPDATE_PERIOD <= 0) return 0;  
         int power_of_two;  
         for (power_of_two = 0; 1<<power_of_two < FILTER_UPDATE_PERIOD; power_of_two++);  
         return (1 << power_of_two) - 1;  
     }  
   
35      Voice::Voice() {      Voice::Voice() {
36          pEngine     = NULL;          pEngine     = NULL;
         pDiskThread = NULL;  
         Active = false;  
         pEG1   = NULL;  
         pEG2   = NULL;  
         pEG3   = NULL;  
         pVCAManipulator  = NULL;  
         pVCFCManipulator = NULL;  
         pVCOManipulator  = NULL;  
         pLFO1  = NULL;  
         pLFO2  = NULL;  
         pLFO3  = NULL;  
         KeyGroup = 0;  
37      }      }
38    
39      Voice::~Voice() {      Voice::~Voice() {
40          if (pEG1)  delete pEG1;          
         if (pEG2)  delete pEG2;  
         if (pEG3)  delete pEG3;  
         if (pLFO1) delete pLFO1;  
         if (pLFO2) delete pLFO2;  
         if (pLFO3) delete pLFO3;  
         if (pVCAManipulator)  delete pVCAManipulator;  
         if (pVCFCManipulator) delete pVCFCManipulator;  
         if (pVCOManipulator)  delete pVCOManipulator;  
     }  
   
     void Voice::SetEngine(Engine* pEngine) {  
         this->pEngine = pEngine;  
   
         // delete old objects  
         if (pEG1) delete pEG1;  
         if (pEG2) delete pEG2;  
         if (pEG3) delete pEG3;  
         if (pVCAManipulator)  delete pVCAManipulator;  
         if (pVCFCManipulator) delete pVCFCManipulator;  
         if (pVCOManipulator)  delete pVCOManipulator;  
         if (pLFO1) delete pLFO1;  
         if (pLFO2) delete pLFO2;  
         if (pLFO3) delete pLFO3;  
   
         // create new ones  
         pEG1   = new EGADSR(pEngine, Event::destination_vca);  
         pEG2   = new EGADSR(pEngine, Event::destination_vcfc);  
         pEG3   = new EGDecay(pEngine, Event::destination_vco);  
         pVCAManipulator  = new VCAManipulator(pEngine);  
         pVCFCManipulator = new VCFCManipulator(pEngine);  
         pVCOManipulator  = new VCOManipulator(pEngine);  
         pLFO1  = new LFO<gig::VCAManipulator>(0.0f, 1.0f, LFO<VCAManipulator>::propagation_top_down, pVCAManipulator, pEngine->pEventPool);  
         pLFO2  = new LFO<gig::VCFCManipulator>(0.0f, 1.0f, LFO<VCFCManipulator>::propagation_top_down, pVCFCManipulator, pEngine->pEventPool);  
         pLFO3  = new LFO<gig::VCOManipulator>(-1200.0f, 1200.0f, LFO<VCOManipulator>::propagation_middle_balanced, pVCOManipulator, pEngine->pEventPool); // +-1 octave (+-1200 cents) max.  
   
         this->pDiskThread = pEngine->pDiskThread;  
         dmsg(6,("Voice::SetEngine()\n"));  
41      }      }
42    
43      /**      EngineChannel* Voice::GetGigEngineChannel() {
44       *  Initializes and triggers the voice, a disk stream will be launched if          return static_cast<EngineChannel*>(pEngineChannel);
45       *  needed.      }
      *  
      *  @param pNoteOnEvent - event that caused triggering of this voice  
      *  @param PitchBend    - MIDI detune factor (-8192 ... +8191)  
      *  @param pInstrument  - points to the loaded instrument which provides sample wave(s) and articulation data  
      *  @param iLayer       - layer number this voice refers to (only if this is a layered sound of course)  
      *  @returns            0 on success, a value < 0 if something failed  
      */  
     int Voice::Trigger(Event* pNoteOnEvent, int PitchBend, ::gig::Instrument* pInstrument, int iLayer) {  
         if (!pInstrument) {  
            dmsg(1,("voice::trigger: !pInstrument\n"));  
            exit(EXIT_FAILURE);  
         }  
   
         Active          = true;  
         MIDIKey         = pNoteOnEvent->Key;  
         pRegion         = pInstrument->GetRegion(MIDIKey);  
         PlaybackState   = playback_state_ram; // we always start playback from RAM cache and switch then to disk if needed  
         Delay           = pNoteOnEvent->FragmentPos();  
         pTriggerEvent   = pNoteOnEvent;  
         pKillEvent      = NULL;  
   
         if (!pRegion) {  
             std::cerr << "gig::Voice: No Region defined for MIDI key " << MIDIKey << std::endl << std::flush;  
             KillImmediately();  
             return -1;  
         }  
   
         KeyGroup = pRegion->KeyGroup;  
   
         // get current dimension values to select the right dimension region  
         //FIXME: controller values for selecting the dimension region here are currently not sample accurate  
         uint DimValues[5] = {0,0,0,0,0};  
         for (int i = pRegion->Dimensions - 1; i >= 0; i--) {  
             switch (pRegion->pDimensionDefinitions[i].dimension) {  
                 case ::gig::dimension_samplechannel:  
                     DimValues[i] = 0; //TODO: we currently ignore this dimension  
                     break;  
                 case ::gig::dimension_layer:  
                     DimValues[i] = iLayer;  
                     // if this is the 1st layer then spawn further voices for all the other layers  
                     if (iLayer == 0)  
                         for (int iNewLayer = 1; iNewLayer < pRegion->pDimensionDefinitions[i].zones; iNewLayer++)  
                             pEngine->LaunchVoice(pNoteOnEvent, iNewLayer);  
                     break;  
                 case ::gig::dimension_velocity:  
                     DimValues[i] = pNoteOnEvent->Velocity;  
                     break;  
                 case ::gig::dimension_channelaftertouch:  
                     DimValues[i] = 0; //TODO: we currently ignore this dimension  
                     break;  
                 case ::gig::dimension_releasetrigger:  
                     DimValues[i] = 0; //TODO: we currently ignore this dimension  
                     break;  
                 case ::gig::dimension_keyboard:  
                     DimValues[i] = (uint) pNoteOnEvent->Key;  
                     break;  
                 case ::gig::dimension_modwheel:  
                     DimValues[i] = pEngine->ControllerTable[1];  
                     break;  
                 case ::gig::dimension_breath:  
                     DimValues[i] = pEngine->ControllerTable[2];  
                     break;  
                 case ::gig::dimension_foot:  
                     DimValues[i] = pEngine->ControllerTable[4];  
                     break;  
                 case ::gig::dimension_portamentotime:  
                     DimValues[i] = pEngine->ControllerTable[5];  
                     break;  
                 case ::gig::dimension_effect1:  
                     DimValues[i] = pEngine->ControllerTable[12];  
                     break;  
                 case ::gig::dimension_effect2:  
                     DimValues[i] = pEngine->ControllerTable[13];  
                     break;  
                 case ::gig::dimension_genpurpose1:  
                     DimValues[i] = pEngine->ControllerTable[16];  
                     break;  
                 case ::gig::dimension_genpurpose2:  
                     DimValues[i] = pEngine->ControllerTable[17];  
                     break;  
                 case ::gig::dimension_genpurpose3:  
                     DimValues[i] = pEngine->ControllerTable[18];  
                     break;  
                 case ::gig::dimension_genpurpose4:  
                     DimValues[i] = pEngine->ControllerTable[19];  
                     break;  
                 case ::gig::dimension_sustainpedal:  
                     DimValues[i] = pEngine->ControllerTable[64];  
                     break;  
                 case ::gig::dimension_portamento:  
                     DimValues[i] = pEngine->ControllerTable[65];  
                     break;  
                 case ::gig::dimension_sostenutopedal:  
                     DimValues[i] = pEngine->ControllerTable[66];  
                     break;  
                 case ::gig::dimension_softpedal:  
                     DimValues[i] = pEngine->ControllerTable[67];  
                     break;  
                 case ::gig::dimension_genpurpose5:  
                     DimValues[i] = pEngine->ControllerTable[80];  
                     break;  
                 case ::gig::dimension_genpurpose6:  
                     DimValues[i] = pEngine->ControllerTable[81];  
                     break;  
                 case ::gig::dimension_genpurpose7:  
                     DimValues[i] = pEngine->ControllerTable[82];  
                     break;  
                 case ::gig::dimension_genpurpose8:  
                     DimValues[i] = pEngine->ControllerTable[83];  
                     break;  
                 case ::gig::dimension_effect1depth:  
                     DimValues[i] = pEngine->ControllerTable[91];  
                     break;  
                 case ::gig::dimension_effect2depth:  
                     DimValues[i] = pEngine->ControllerTable[92];  
                     break;  
                 case ::gig::dimension_effect3depth:  
                     DimValues[i] = pEngine->ControllerTable[93];  
                     break;  
                 case ::gig::dimension_effect4depth:  
                     DimValues[i] = pEngine->ControllerTable[94];  
                     break;  
                 case ::gig::dimension_effect5depth:  
                     DimValues[i] = pEngine->ControllerTable[95];  
                     break;  
                 case ::gig::dimension_none:  
                     std::cerr << "gig::Voice::Trigger() Error: dimension=none\n" << std::flush;  
                     break;  
                 default:  
                     std::cerr << "gig::Voice::Trigger() Error: Unknown dimension\n" << std::flush;  
             }  
         }  
         pDimRgn = pRegion->GetDimensionRegionByValue(DimValues[4],DimValues[3],DimValues[2],DimValues[1],DimValues[0]);  
   
         // get starting crossfade volume level  
         switch (pDimRgn->AttenuationController.type) {  
             case ::gig::attenuation_ctrl_t::type_channelaftertouch:  
                 CrossfadeVolume = 1.0f; //TODO: aftertouch not supported yet  
                 break;  
             case ::gig::attenuation_ctrl_t::type_velocity:  
                 CrossfadeVolume = CrossfadeAttenuation(pNoteOnEvent->Velocity);  
                 break;  
             case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate  
                 CrossfadeVolume = CrossfadeAttenuation(pEngine->ControllerTable[pDimRgn->AttenuationController.controller_number]);  
                 break;  
             case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined  
             default:  
                 CrossfadeVolume = 1.0f;  
         }  
   
         pSample = pDimRgn->pSample; // sample won't change until the voice is finished  
   
         Pos = pDimRgn->SampleStartOffset; // offset where we should start playback of sample (0 - 2000 sample points)  
   
         // Check if the sample needs disk streaming or is too short for that  
         long cachedsamples = pSample->GetCache().Size / pSample->FrameSize;  
         DiskVoice          = cachedsamples < pSample->SamplesTotal;  
   
         if (DiskVoice) { // voice to be streamed from disk  
             MaxRAMPos = cachedsamples - (pEngine->MaxSamplesPerCycle << 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)  
46    
47              // check if there's a loop defined which completely fits into the cached (RAM) part of the sample      void Voice::SetEngine(LinuxSampler::Engine* pEngine) {
48              if (pSample->Loops && pSample->LoopEnd <= MaxRAMPos) {          Engine* engine = static_cast<Engine*>(pEngine);
49                  RAMLoop        = true;          this->pEngine     = engine;
50                  LoopCyclesLeft = pSample->LoopPlayCount;          this->pDiskThread = engine->pDiskThread;
51              }          dmsg(6,("Voice::SetEngine()\n"));
52              else RAMLoop = false;      }
53    
54              if (pDiskThread->OrderNewStream(&DiskStreamRef, pSample, MaxRAMPos, !RAMLoop) < 0) {      Voice::SampleInfo Voice::GetSampleInfo() {
55                  dmsg(1,("Disk stream order failed!\n"));          SampleInfo si;
56                  KillImmediately();          si.SampleRate       = pSample->SamplesPerSecond;
57                  return -1;          si.ChannelCount     = pSample->Channels;
58              }          si.FrameSize        = pSample->FrameSize;
59              dmsg(4,("Disk voice launched (cached samples: %d, total Samples: %d, MaxRAMPos: %d, RAMLooping: %s)\n", cachedsamples, pSample->SamplesTotal, MaxRAMPos, (RAMLoop) ? "yes" : "no"));          si.BitDepth         = pSample->BitDepth;
60          }          si.TotalFrameCount  = pSample->SamplesTotal;
         else { // RAM only voice  
             MaxRAMPos = cachedsamples;  
             if (pSample->Loops) {  
                 RAMLoop        = true;  
                 LoopCyclesLeft = pSample->LoopPlayCount;  
             }  
             else RAMLoop = false;  
             dmsg(4,("RAM only voice launched (Looping: %s)\n", (RAMLoop) ? "yes" : "no"));  
         }  
61    
62            si.HasLoops       = pRegion->SampleLoops;
63            si.LoopStart      = (si.HasLoops) ? pRegion->pSampleLoops[0].LoopStart  : 0;
64            si.LoopLength     = (si.HasLoops) ? pRegion->pSampleLoops[0].LoopLength : 0;
65            si.LoopPlayCount  = pSample->LoopPlayCount;
66            si.Unpitched      = !pRegion->PitchTrack;
67    
68          // calculate initial pitch value          return si;
69          {      }
             double pitchbasecents = pDimRgn->FineTune * 10;  
             if (pDimRgn->PitchTrack) pitchbasecents += (MIDIKey - (int) pDimRgn->UnityNote) * 100;  
             this->PitchBase = RTMath::CentsToFreqRatio(pitchbasecents) * (double(pSample->SamplesPerSecond) / double(pEngine->pAudioOutputDevice->SampleRate()));  
             this->PitchBend = RTMath::CentsToFreqRatio(((double) PitchBend / 8192.0) * 200.0); // pitchbend wheel +-2 semitones = 200 cents  
         }  
70    
71        Voice::RegionInfo Voice::GetRegionInfo() {
72            RegionInfo ri;
73            ri.UnityNote = pRegion->UnityNote;
74            ri.FineTune  = pRegion->FineTune;
75            ri.Pan       = pRegion->Pan;
76            ri.SampleStartOffset = pRegion->SampleStartOffset;
77    
78          Volume = pDimRgn->GetVelocityAttenuation(pNoteOnEvent->Velocity) / 32768.0f; // we downscale by 32768 to convert from int16 value range to DSP value range (which is -1.0..1.0)          ri.EG1PreAttack        = pRegion->EG1PreAttack;
79            ri.EG1Attack           = pRegion->EG1Attack;
80            ri.EG1Hold             = pRegion->EG1Hold;
81            ri.EG1Decay1           = pRegion->EG1Decay1;
82            ri.EG1Decay2           = pRegion->EG1Decay2;
83            ri.EG1Sustain          = pRegion->EG1Sustain;
84            ri.EG1InfiniteSustain  = pRegion->EG1InfiniteSustain;
85            ri.EG1Release          = pRegion->EG1Release;
86    
87            ri.EG2PreAttack        = pRegion->EG2PreAttack;
88            ri.EG2Attack           = pRegion->EG2Attack;
89            ri.EG2Decay1           = pRegion->EG2Decay1;
90            ri.EG2Decay2           = pRegion->EG2Decay2;
91            ri.EG2Sustain          = pRegion->EG2Sustain;
92            ri.EG2InfiniteSustain  = pRegion->EG2InfiniteSustain;
93            ri.EG2Release          = pRegion->EG2Release;
94    
95          // setup EG 1 (VCA EG)          ri.EG3Attack     = pRegion->EG3Attack;
96          {          ri.EG3Depth      = pRegion->EG3Depth;
97              // get current value of EG1 controller          ri.VCFEnabled    = pRegion->VCFEnabled;
98              double eg1controllervalue;          ri.VCFType       = pRegion->VCFType;
99              switch (pDimRgn->EG1Controller.type) {          ri.VCFResonance  = pRegion->VCFResonance;
                 case ::gig::eg1_ctrl_t::type_none: // no controller defined  
                     eg1controllervalue = 0;  
                     break;  
                 case ::gig::eg1_ctrl_t::type_channelaftertouch:  
                     eg1controllervalue = 0; // TODO: aftertouch not yet supported  
                     break;  
                 case ::gig::eg1_ctrl_t::type_velocity:  
                     eg1controllervalue = pNoteOnEvent->Velocity;  
                     break;  
                 case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller  
                     eg1controllervalue = pEngine->ControllerTable[pDimRgn->EG1Controller.controller_number];  
                     break;  
             }  
             if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;  
100    
101              // calculate influence of EG1 controller on EG1's parameters (TODO: needs to be fine tuned)          ri.ReleaseTriggerDecay = pRegion->ReleaseTriggerDecay;
             double eg1attack  = (pDimRgn->EG1ControllerAttackInfluence)  ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerAttackInfluence)  * eg1controllervalue : 0.0;  
             double eg1decay   = (pDimRgn->EG1ControllerDecayInfluence)   ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerDecayInfluence)   * eg1controllervalue : 0.0;  
             double eg1release = (pDimRgn->EG1ControllerReleaseInfluence) ? 0.0001 * (double) (1 << pDimRgn->EG1ControllerReleaseInfluence) * eg1controllervalue : 0.0;  
   
             pEG1->Trigger(pDimRgn->EG1PreAttack,  
                           pDimRgn->EG1Attack + eg1attack,  
                           pDimRgn->EG1Hold,  
                           pSample->LoopStart,  
                           pDimRgn->EG1Decay1 + eg1decay,  
                           pDimRgn->EG1Decay2 + eg1decay,  
                           pDimRgn->EG1InfiniteSustain,  
                           pDimRgn->EG1Sustain,  
                           pDimRgn->EG1Release + eg1release,  
                           Delay);  
         }  
102    
103            return ri;
104        }
105    
106      #if ENABLE_FILTER      Voice::InstrumentInfo Voice::GetInstrumentInfo() {
107          // setup EG 2 (VCF Cutoff EG)          InstrumentInfo ii;
108          {          ii.FineTune = GetGigEngineChannel()->pInstrument->FineTune;
109              // get current value of EG2 controller          ii.PitchbendRange = GetGigEngineChannel()->pInstrument->PitchbendRange;
             double eg2controllervalue;  
             switch (pDimRgn->EG2Controller.type) {  
                 case ::gig::eg2_ctrl_t::type_none: // no controller defined  
                     eg2controllervalue = 0;  
                     break;  
                 case ::gig::eg2_ctrl_t::type_channelaftertouch:  
                     eg2controllervalue = 0; // TODO: aftertouch not yet supported  
                     break;  
                 case ::gig::eg2_ctrl_t::type_velocity:  
                     eg2controllervalue = pNoteOnEvent->Velocity;  
                     break;  
                 case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller  
                     eg2controllervalue = pEngine->ControllerTable[pDimRgn->EG2Controller.controller_number];  
                     break;  
             }  
             if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;  
   
             // calculate influence of EG2 controller on EG2's parameters (TODO: needs to be fine tuned)  
             double eg2attack  = (pDimRgn->EG2ControllerAttackInfluence)  ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerAttackInfluence)  * eg2controllervalue : 0.0;  
             double eg2decay   = (pDimRgn->EG2ControllerDecayInfluence)   ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerDecayInfluence)   * eg2controllervalue : 0.0;  
             double eg2release = (pDimRgn->EG2ControllerReleaseInfluence) ? 0.0001 * (double) (1 << pDimRgn->EG2ControllerReleaseInfluence) * eg2controllervalue : 0.0;  
   
             pEG2->Trigger(pDimRgn->EG2PreAttack,  
                           pDimRgn->EG2Attack + eg2attack,  
                           false,  
                           pSample->LoopStart,  
                           pDimRgn->EG2Decay1 + eg2decay,  
                           pDimRgn->EG2Decay2 + eg2decay,  
                           pDimRgn->EG2InfiniteSustain,  
                           pDimRgn->EG2Sustain,  
                           pDimRgn->EG2Release + eg2release,  
                           Delay);  
         }  
     #endif // ENABLE_FILTER  
   
110    
111          // setup EG 3 (VCO EG)          return ii;
112          {      }
           double eg3depth = RTMath::CentsToFreqRatio(pDimRgn->EG3Depth);  
           pEG3->Trigger(eg3depth, pDimRgn->EG3Attack, Delay);  
         }  
113    
114        double Voice::GetSampleAttenuation() {
115            return pRegion->SampleAttenuation;
116        }
117    
118          // setup LFO 1 (VCA LFO)      double Voice::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
119          {          return pRegion->GetVelocityAttenuation(MIDIKeyVelocity);
120              uint16_t lfo1_internal_depth;      }
             switch (pDimRgn->LFO1Controller) {  
                 case ::gig::lfo1_ctrl_internal:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 0; // no external controller  
                     break;  
                 case ::gig::lfo1_ctrl_modwheel:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo1_ctrl_breath:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 2; // MIDI controller 2  
                     break;  
                 case ::gig::lfo1_ctrl_internal_modwheel:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo1_ctrl_internal_breath:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 2; // MIDI controller 2  
                     break;  
                 default:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 0; // no external controller  
             }  
             pLFO1->Trigger(pDimRgn->LFO1Frequency,  
                           lfo1_internal_depth,  
                           pDimRgn->LFO1ControlDepth,  
                           pEngine->ControllerTable[pLFO1->ExtController],  
                           pDimRgn->LFO1FlipPhase,  
                           pEngine->SampleRate,  
                           Delay);  
         }  
121    
122      #if ENABLE_FILTER      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
123          // setup LFO 2 (VCF Cutoff LFO)          return pRegion->GetVelocityRelease(MIDIKeyVelocity);
124          {      }
             uint16_t lfo2_internal_depth;  
             switch (pDimRgn->LFO2Controller) {  
                 case ::gig::lfo2_ctrl_internal:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 0; // no external controller  
                     break;  
                 case ::gig::lfo2_ctrl_modwheel:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo2_ctrl_foot:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 4; // MIDI controller 4  
                     break;  
                 case ::gig::lfo2_ctrl_internal_modwheel:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo2_ctrl_internal_foot:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 4; // MIDI controller 4  
                     break;  
                 default:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 0; // no external controller  
             }  
             pLFO2->Trigger(pDimRgn->LFO2Frequency,  
                           lfo2_internal_depth,  
                           pDimRgn->LFO2ControlDepth,  
                           pEngine->ControllerTable[pLFO2->ExtController],  
                           pDimRgn->LFO2FlipPhase,  
                           pEngine->SampleRate,  
                           Delay);  
         }  
     #endif // ENABLE_FILTER  
125    
126          // setup LFO 3 (VCO LFO)      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {
127          {          if (itEvent->Type == Event::type_control_change && itEvent->Param.CC.Controller) { // if (valid) MIDI control change event
128              uint16_t lfo3_internal_depth;              if (pRegion->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&
129              switch (pDimRgn->LFO3Controller) {                  itEvent->Param.CC.Controller == pRegion->AttenuationController.controller_number) {
130                  case ::gig::lfo3_ctrl_internal:                  CrossfadeSmoother.update(AbstractEngine::CrossfadeCurve[CrossfadeAttenuation(itEvent->Param.CC.Value)]);
                     lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;  
                     pLFO3->ExtController = 0; // no external controller  
                     break;  
                 case ::gig::lfo3_ctrl_modwheel:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo3_ctrl_aftertouch:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 0; // TODO: aftertouch not implemented yet  
                     break;  
                 case ::gig::lfo3_ctrl_internal_modwheel:  
                     lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;  
                     pLFO3->ExtController = 1; // MIDI controller 1  
                     break;  
                 case ::gig::lfo3_ctrl_internal_aftertouch:  
                     lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;  
                     pLFO1->ExtController = 0; // TODO: aftertouch not implemented yet  
                     break;  
                 default:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 0; // no external controller  
131              }              }
             pLFO3->Trigger(pDimRgn->LFO3Frequency,  
                           lfo3_internal_depth,  
                           pDimRgn->LFO3ControlDepth,  
                           pEngine->ControllerTable[pLFO3->ExtController],  
                           false,  
                           pEngine->SampleRate,  
                           Delay);  
132          }          }
133        }
134    
135      #if ENABLE_FILTER      void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {
136          #if FORCE_FILTER_USAGE          int ccvalue = itEvent->Param.CC.Value;
137          FilterLeft.Enabled = FilterRight.Enabled = true;          if (VCFCutoffCtrl.value == ccvalue) return;
138          #else // use filter only if instrument file told so          VCFCutoffCtrl.value == ccvalue;
139          FilterLeft.Enabled = FilterRight.Enabled = pDimRgn->VCFEnabled;          if (pRegion->VCFCutoffControllerInvert)  ccvalue = 127 - ccvalue;
140          #endif // FORCE_FILTER_USAGE          if (ccvalue < pRegion->VCFVelocityScale) ccvalue = pRegion->VCFVelocityScale;
141          if (pDimRgn->VCFEnabled) {          float cutoff = CutoffBase * float(ccvalue);
142              #ifdef OVERRIDE_FILTER_CUTOFF_CTRL          if (cutoff > 127.0f) cutoff = 127.0f;
             VCFCutoffCtrl.controller = OVERRIDE_FILTER_CUTOFF_CTRL;  
             #else // use the one defined in the instrument file  
             switch (pDimRgn->VCFCutoffController) {  
                 case ::gig::vcf_cutoff_ctrl_modwheel:  
                     VCFCutoffCtrl.controller = 1;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_effect1:  
                     VCFCutoffCtrl.controller = 12;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_effect2:  
                     VCFCutoffCtrl.controller = 13;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_breath:  
                     VCFCutoffCtrl.controller = 2;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_foot:  
                     VCFCutoffCtrl.controller = 4;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_sustainpedal:  
                     VCFCutoffCtrl.controller = 64;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_softpedal:  
                     VCFCutoffCtrl.controller = 67;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_genpurpose7:  
                     VCFCutoffCtrl.controller = 82;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_genpurpose8:  
                     VCFCutoffCtrl.controller = 83;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_aftertouch: //TODO: not implemented yet  
                 case ::gig::vcf_cutoff_ctrl_none:  
                 default:  
                     VCFCutoffCtrl.controller = 0;  
                     break;  
             }  
             #endif // OVERRIDE_FILTER_CUTOFF_CTRL  
   
             #ifdef OVERRIDE_FILTER_RES_CTRL  
             VCFResonanceCtrl.controller = OVERRIDE_FILTER_RES_CTRL;  
             #else // use the one defined in the instrument file  
             switch (pDimRgn->VCFResonanceController) {  
                 case ::gig::vcf_res_ctrl_genpurpose3:  
                     VCFResonanceCtrl.controller = 18;  
                     break;  
                 case ::gig::vcf_res_ctrl_genpurpose4:  
                     VCFResonanceCtrl.controller = 19;  
                     break;  
                 case ::gig::vcf_res_ctrl_genpurpose5:  
                     VCFResonanceCtrl.controller = 80;  
                     break;  
                 case ::gig::vcf_res_ctrl_genpurpose6:  
                     VCFResonanceCtrl.controller = 81;  
                     break;  
                 case ::gig::vcf_res_ctrl_none:  
                 default:  
                     VCFResonanceCtrl.controller = 0;  
             }  
             #endif // OVERRIDE_FILTER_RES_CTRL  
   
             #ifndef OVERRIDE_FILTER_TYPE  
             FilterLeft.SetType(pDimRgn->VCFType);  
             FilterRight.SetType(pDimRgn->VCFType);  
             #else // override filter type  
             FilterLeft.SetType(OVERRIDE_FILTER_TYPE);  
             FilterRight.SetType(OVERRIDE_FILTER_TYPE);  
             #endif // OVERRIDE_FILTER_TYPE  
   
             VCFCutoffCtrl.value    = pEngine->ControllerTable[VCFCutoffCtrl.controller];  
             VCFResonanceCtrl.value = pEngine->ControllerTable[VCFResonanceCtrl.controller];  
   
             // calculate cutoff frequency  
             float cutoff = (!VCFCutoffCtrl.controller)  
                 ? exp((float) (127 - pNoteOnEvent->Velocity) * (float) pDimRgn->VCFVelocityScale * 6.2E-5f * FILTER_CUTOFF_COEFF) * FILTER_CUTOFF_MAX  
                 : exp((float) VCFCutoffCtrl.value * 0.00787402f * FILTER_CUTOFF_COEFF) * FILTER_CUTOFF_MAX;  
   
             // calculate resonance  
             float resonance = (float) VCFResonanceCtrl.value * 0.00787f;   // 0.0..1.0  
             if (pDimRgn->VCFKeyboardTracking) {  
                 resonance += (float) (pNoteOnEvent->Key - pDimRgn->VCFKeyboardTrackingBreakpoint) * 0.00787f;  
             }  
             Constrain(resonance, 0.0, 1.0); // correct resonance if outside allowed value range (0.0..1.0)  
   
             VCFCutoffCtrl.fvalue    = cutoff - FILTER_CUTOFF_MIN;  
             VCFResonanceCtrl.fvalue = resonance;  
   
             FilterLeft.SetParameters(cutoff,  resonance, pEngine->SampleRate);  
             FilterRight.SetParameters(cutoff, resonance, pEngine->SampleRate);  
   
             FilterUpdateCounter = -1;  
         }  
         else {  
             VCFCutoffCtrl.controller    = 0;  
             VCFResonanceCtrl.controller = 0;  
         }  
     #endif // ENABLE_FILTER  
143    
144          return 0; // success          VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of fFinalCutoff next time
145            fFinalCutoff = cutoff;
146      }      }
147    
148      /**      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {
149       *  Renders the audio data for this voice for the current audio fragment.          float crossfadeVolume;
150       *  The sample input data can either come from RAM (cached sample or sample          switch (pRegion->AttenuationController.type) {
151       *  part) or directly from disk. The output signal will be rendered by              case ::gig::attenuation_ctrl_t::type_channelaftertouch:
152       *  resampling / interpolation. If this voice is a disk streaming voice and                  crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(GetGigEngineChannel()->ControllerTable[128])];
      *  the voice completely played back the cached RAM part of the sample, it  
      *  will automatically switch to disk playback for the next RenderAudio()  
      *  call.  
      *  
      *  @param Samples - number of samples to be rendered in this audio fragment cycle  
      */  
     void Voice::Render(uint Samples) {  
   
         // Reset the synthesis parameter matrix  
         pEngine->ResetSynthesisParameters(Event::destination_vca, this->Volume * this->CrossfadeVolume * pEngine->GlobalVolume);  
         pEngine->ResetSynthesisParameters(Event::destination_vco, this->PitchBase);  
     #if ENABLE_FILTER  
         pEngine->ResetSynthesisParameters(Event::destination_vcfc, VCFCutoffCtrl.fvalue);  
         pEngine->ResetSynthesisParameters(Event::destination_vcfr, VCFResonanceCtrl.fvalue);  
     #endif // ENABLE_FILTER  
   
   
         // Apply events to the synthesis parameter matrix  
         ProcessEvents(Samples);  
   
   
         // Let all modulators write their parameter changes to the synthesis parameter matrix for the current audio fragment  
         pEG1->Process(Samples, pEngine->pMIDIKeyInfo[MIDIKey].pEvents, pTriggerEvent, this->Pos, this->PitchBase * this->PitchBend, pKillEvent);  
     #if ENABLE_FILTER  
         pEG2->Process(Samples, pEngine->pMIDIKeyInfo[MIDIKey].pEvents, pTriggerEvent, this->Pos, this->PitchBase * this->PitchBend);  
     #endif // ENABLE_FILTER  
         pEG3->Process(Samples);  
         pLFO1->Process(Samples);  
     #if ENABLE_FILTER  
         pLFO2->Process(Samples);  
     #endif // ENABLE_FILTER  
         pLFO3->Process(Samples);  
   
   
     #if ENABLE_FILTER  
         CalculateBiquadParameters(Samples); // calculate the final biquad filter parameters  
     #endif // ENABLE_FILTER  
   
   
         switch (this->PlaybackState) {  
   
             case playback_state_ram: {  
                     if (RAMLoop) InterpolateAndLoop(Samples, (sample_t*) pSample->GetCache().pStart, Delay);  
                     else         Interpolate(Samples, (sample_t*) pSample->GetCache().pStart, Delay);  
                     if (DiskVoice) {  
                         // check if we reached the allowed limit of the sample RAM cache  
                         if (Pos > MaxRAMPos) {  
                             dmsg(5,("Voice: switching to disk playback (Pos=%f)\n", Pos));  
                             this->PlaybackState = playback_state_disk;  
                         }  
                     }  
                     else if (Pos >= pSample->GetCache().Size / pSample->FrameSize) {  
                         this->PlaybackState = playback_state_end;  
                     }  
                 }  
                 break;  
   
             case playback_state_disk: {  
                     if (!DiskStreamRef.pStream) {  
                         // check if the disk thread created our ordered disk stream in the meantime  
                         DiskStreamRef.pStream = pDiskThread->AskForCreatedStream(DiskStreamRef.OrderID);  
                         if (!DiskStreamRef.pStream) {  
                             std::cout << stderr << "Disk stream not available in time!" << std::endl << std::flush;  
                             KillImmediately();  
                             return;  
                         }  
                         DiskStreamRef.pStream->IncrementReadPos(pSample->Channels * (RTMath::DoubleToInt(Pos) - MaxRAMPos));  
                         Pos -= RTMath::DoubleToInt(Pos);  
                     }  
   
                     // add silence sample at the end if we reached the end of the stream (for the interpolator)  
                     if (DiskStreamRef.State == Stream::state_end && DiskStreamRef.pStream->GetReadSpace() < (pEngine->MaxSamplesPerCycle << MAX_PITCH) / pSample->Channels) {  
                         DiskStreamRef.pStream->WriteSilence((pEngine->MaxSamplesPerCycle << MAX_PITCH) / pSample->Channels);  
                         this->PlaybackState = playback_state_end;  
                     }  
   
                     sample_t* ptr = DiskStreamRef.pStream->GetReadPtr(); // get the current read_ptr within the ringbuffer where we read the samples from  
                     Interpolate(Samples, ptr, Delay);  
                     DiskStreamRef.pStream->IncrementReadPos(RTMath::DoubleToInt(Pos) * pSample->Channels);  
                     Pos -= RTMath::DoubleToInt(Pos);  
                 }  
153                  break;                  break;
154                case ::gig::attenuation_ctrl_t::type_velocity:
155              case playback_state_end:                  crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(MIDIKeyVelocity)];
                 KillImmediately(); // free voice  
156                  break;                  break;
157                case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate
158                    crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(GetGigEngineChannel()->ControllerTable[pRegion->AttenuationController.controller_number])];
159                    break;
160                case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined
161                default:
162                    crossfadeVolume = 1.0f;
163          }          }
164    
165            return crossfadeVolume;
166        }
167    
168          // Reset synthesis event lists (except VCO, as VCO events apply channel wide currently)      double Voice::GetEG1ControllerValue(uint8_t MIDIKeyVelocity) {
169          pEngine->pSynthesisEvents[Event::destination_vca]->clear();          double eg1controllervalue = 0;
170      #if ENABLE_FILTER          switch (pRegion->EG1Controller.type) {
171          pEngine->pSynthesisEvents[Event::destination_vcfc]->clear();              case ::gig::eg1_ctrl_t::type_none: // no controller defined
172          pEngine->pSynthesisEvents[Event::destination_vcfr]->clear();                  eg1controllervalue = 0;
173      #endif // ENABLE_FILTER                  break;
174                case ::gig::eg1_ctrl_t::type_channelaftertouch:
175          // Reset delay                  eg1controllervalue = GetGigEngineChannel()->ControllerTable[128];
176          Delay = 0;                  break;
177                case ::gig::eg1_ctrl_t::type_velocity:
178          pTriggerEvent = NULL;                  eg1controllervalue = MIDIKeyVelocity;
179                    break;
180          // If release stage finished, let the voice be killed              case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller
181          if (pEG1->GetStage() == EGADSR::stage_end) this->PlaybackState = playback_state_end;                  eg1controllervalue = GetGigEngineChannel()->ControllerTable[pRegion->EG1Controller.controller_number];
182      }                  break;
   
     /**  
      *  Resets voice variables. Should only be called if rendering process is  
      *  suspended / not running.  
      */  
     void Voice::Reset() {  
         pLFO1->Reset();  
         pLFO2->Reset();  
         pLFO3->Reset();  
         DiskStreamRef.pStream = NULL;  
         DiskStreamRef.hStream = 0;  
         DiskStreamRef.State   = Stream::state_unused;  
         DiskStreamRef.OrderID = 0;  
         Active = false;  
     }  
   
     /**  
      *  Process the control change event lists of the engine for the current  
      *  audio fragment. Event values will be applied to the synthesis parameter  
      *  matrix.  
      *  
      *  @param Samples - number of samples to be rendered in this audio fragment cycle  
      */  
     void Voice::ProcessEvents(uint Samples) {  
   
         // dispatch control change events  
         Event* pCCEvent = pEngine->pCCEvents->first();  
         if (Delay) { // skip events that happened before this voice was triggered  
             while (pCCEvent && pCCEvent->FragmentPos() <= Delay) pCCEvent = pEngine->pCCEvents->next();  
         }  
         while (pCCEvent) {  
             if (pCCEvent->Controller) { // if valid MIDI controller  
                 #if ENABLE_FILTER  
                 if (pCCEvent->Controller == VCFCutoffCtrl.controller) {  
                     pEngine->pSynthesisEvents[Event::destination_vcfc]->alloc_assign(*pCCEvent);  
                 }  
                 if (pCCEvent->Controller == VCFResonanceCtrl.controller) {  
                     pEngine->pSynthesisEvents[Event::destination_vcfr]->alloc_assign(*pCCEvent);  
                 }  
                 #endif // ENABLE_FILTER  
                 if (pCCEvent->Controller == pLFO1->ExtController) {  
                     pLFO1->SendEvent(pCCEvent);  
                 }  
                 #if ENABLE_FILTER  
                 if (pCCEvent->Controller == pLFO2->ExtController) {  
                     pLFO2->SendEvent(pCCEvent);  
                 }  
                 #endif // ENABLE_FILTER  
                 if (pCCEvent->Controller == pLFO3->ExtController) {  
                     pLFO3->SendEvent(pCCEvent);  
                 }  
                 if (pDimRgn->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&  
                     pCCEvent->Controller == pDimRgn->AttenuationController.controller_number) { // if crossfade event  
                     pEngine->pSynthesisEvents[Event::destination_vca]->alloc_assign(*pCCEvent);  
                 }  
             }  
   
             pCCEvent = pEngine->pCCEvents->next();  
         }  
   
   
         // process pitch events  
         {  
             RTEList<Event>* pVCOEventList = pEngine->pSynthesisEvents[Event::destination_vco];  
             Event* pVCOEvent = pVCOEventList->first();  
             if (Delay) { // skip events that happened before this voice was triggered  
                 while (pVCOEvent && pVCOEvent->FragmentPos() <= Delay) pVCOEvent = pVCOEventList->next();  
             }  
             // apply old pitchbend value until first pitch event occurs  
             if (this->PitchBend != 1.0) {  
                 uint end = (pVCOEvent) ? pVCOEvent->FragmentPos() : Samples;  
                 for (uint i = Delay; i < end; i++) {  
                     pEngine->pSynthesisParameters[Event::destination_vco][i] *= this->PitchBend;  
                 }  
             }  
             float pitch;  
             while (pVCOEvent) {  
                 Event* pNextVCOEvent = pVCOEventList->next();  
   
                 // calculate the influence length of this event (in sample points)  
                 uint end = (pNextVCOEvent) ? pNextVCOEvent->FragmentPos() : Samples;  
   
                 pitch = RTMath::CentsToFreqRatio(((double) pVCOEvent->Pitch / 8192.0) * 200.0); // +-two semitones = +-200 cents  
   
                 // apply pitch value to the pitch parameter sequence  
                 for (uint i = pVCOEvent->FragmentPos(); i < end; i++) {  
                     pEngine->pSynthesisParameters[Event::destination_vco][i] *= pitch;  
                 }  
   
                 pVCOEvent = pNextVCOEvent;  
             }  
             if (pVCOEventList->last()) this->PitchBend = pitch;  
         }  
   
         // process volume / attenuation events (TODO: we only handle and _expect_ crossfade events here ATM !)  
         {  
             RTEList<Event>* pVCAEventList = pEngine->pSynthesisEvents[Event::destination_vca];  
             Event* pVCAEvent = pVCAEventList->first();  
             if (Delay) { // skip events that happened before this voice was triggered  
                 while (pVCAEvent && pVCAEvent->FragmentPos() <= Delay) pVCAEvent = pVCAEventList->next();  
             }  
             float crossfadevolume;  
             while (pVCAEvent) {  
                 Event* pNextVCAEvent = pVCAEventList->next();  
   
                 // calculate the influence length of this event (in sample points)  
                 uint end = (pNextVCAEvent) ? pNextVCAEvent->FragmentPos() : Samples;  
   
                 crossfadevolume = CrossfadeAttenuation(pVCAEvent->Value);  
   
                 float effective_volume = crossfadevolume * this->Volume * pEngine->GlobalVolume;  
   
                 // apply volume value to the volume parameter sequence  
                 for (uint i = pVCAEvent->FragmentPos(); i < end; i++) {  
                     pEngine->pSynthesisParameters[Event::destination_vca][i] = effective_volume;  
                 }  
   
                 pVCAEvent = pNextVCAEvent;  
             }  
             if (pVCAEventList->last()) this->CrossfadeVolume = crossfadevolume;  
183          }          }
184            if (pRegion->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;
185    
186      #if ENABLE_FILTER          return eg1controllervalue;
187          // process filter cutoff events      }
         {  
             RTEList<Event>* pCutoffEventList = pEngine->pSynthesisEvents[Event::destination_vcfc];  
             Event* pCutoffEvent = pCutoffEventList->first();  
             if (Delay) { // skip events that happened before this voice was triggered  
                 while (pCutoffEvent && pCutoffEvent->FragmentPos() <= Delay) pCutoffEvent = pCutoffEventList->next();  
             }  
             float cutoff;  
             while (pCutoffEvent) {  
                 Event* pNextCutoffEvent = pCutoffEventList->next();  
   
                 // calculate the influence length of this event (in sample points)  
                 uint end = (pNextCutoffEvent) ? pNextCutoffEvent->FragmentPos() : Samples;  
188    
189                  cutoff = exp((float) pCutoffEvent->Value * 0.00787402f * FILTER_CUTOFF_COEFF) * FILTER_CUTOFF_MAX - FILTER_CUTOFF_MIN;      Voice::EGInfo Voice::CalculateEG1ControllerInfluence(double eg1ControllerValue) {
190            EGInfo eg;
191            // (eg1attack is different from the others)
192            eg.Attack  = (pRegion->EG1ControllerAttackInfluence)  ?
193                1 + 0.031 * (double) (pRegion->EG1ControllerAttackInfluence == 1 ?
194                                      1 : 1 << pRegion->EG1ControllerAttackInfluence) * eg1ControllerValue : 1.0;
195            eg.Decay   = (pRegion->EG1ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pRegion->EG1ControllerDecayInfluence)   * eg1ControllerValue : 1.0;
196            eg.Release = (pRegion->EG1ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pRegion->EG1ControllerReleaseInfluence) * eg1ControllerValue : 1.0;
197    
198                  // apply cutoff frequency to the cutoff parameter sequence          return eg;
199                  for (uint i = pCutoffEvent->FragmentPos(); i < end; i++) {      }
                     pEngine->pSynthesisParameters[Event::destination_vcfc][i] = cutoff;  
                 }  
200    
201                  pCutoffEvent = pNextCutoffEvent;      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {
202              }          double eg2controllervalue = 0;
203              if (pCutoffEventList->last()) VCFCutoffCtrl.fvalue = cutoff; // needed for initialization of parameter matrix next time          switch (pRegion->EG2Controller.type) {
204                case ::gig::eg2_ctrl_t::type_none: // no controller defined
205                    eg2controllervalue = 0;
206                    break;
207                case ::gig::eg2_ctrl_t::type_channelaftertouch:
208                    eg2controllervalue = GetGigEngineChannel()->ControllerTable[128];
209                    break;
210                case ::gig::eg2_ctrl_t::type_velocity:
211                    eg2controllervalue = MIDIKeyVelocity;
212                    break;
213                case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller
214                    eg2controllervalue = GetGigEngineChannel()->ControllerTable[pRegion->EG2Controller.controller_number];
215                    break;
216          }          }
217            if (pRegion->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;
218    
219          // process filter resonance events          return eg2controllervalue;
220          {      }
             RTEList<Event>* pResonanceEventList = pEngine->pSynthesisEvents[Event::destination_vcfr];  
             Event* pResonanceEvent = pResonanceEventList->first();  
             if (Delay) { // skip events that happened before this voice was triggered  
                 while (pResonanceEvent && pResonanceEvent->FragmentPos() <= Delay) pResonanceEvent = pResonanceEventList->next();  
             }  
             while (pResonanceEvent) {  
                 Event* pNextResonanceEvent = pResonanceEventList->next();  
   
                 // calculate the influence length of this event (in sample points)  
                 uint end = (pNextResonanceEvent) ? pNextResonanceEvent->FragmentPos() : Samples;  
   
                 // convert absolute controller value to differential  
                 int ctrldelta = pResonanceEvent->Value - VCFResonanceCtrl.value;  
                 VCFResonanceCtrl.value = pResonanceEvent->Value;  
221    
222                  float resonancedelta = (float) ctrldelta * 0.00787f; // 0.0..1.0      Voice::EGInfo Voice::CalculateEG2ControllerInfluence(double eg2ControllerValue) {
223            EGInfo eg;
224            eg.Attack  = (pRegion->EG2ControllerAttackInfluence)  ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerAttackInfluence)  * eg2ControllerValue : 1.0;
225            eg.Decay   = (pRegion->EG2ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerDecayInfluence)   * eg2ControllerValue : 1.0;
226            eg.Release = (pRegion->EG2ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerReleaseInfluence) * eg2ControllerValue : 1.0;
227    
228                  // apply cutoff frequency to the cutoff parameter sequence          return eg;
229                  for (uint i = pResonanceEvent->FragmentPos(); i < end; i++) {      }
                     pEngine->pSynthesisParameters[Event::destination_vcfr][i] += resonancedelta;  
                 }  
230    
231                  pResonanceEvent = pNextResonanceEvent;      void Voice::InitLFO1() {
232              }          uint16_t lfo1_internal_depth;
233              if (pResonanceEventList->last()) VCFResonanceCtrl.fvalue = pResonanceEventList->last()->Value * 0.00787f; // needed for initialization of parameter matrix next time          switch (pRegion->LFO1Controller) {
234                case ::gig::lfo1_ctrl_internal:
235                    lfo1_internal_depth  = pRegion->LFO1InternalDepth;
236                    pLFO1->ExtController = 0; // no external controller
237                    bLFO1Enabled         = (lfo1_internal_depth > 0);
238                    break;
239                case ::gig::lfo1_ctrl_modwheel:
240                    lfo1_internal_depth  = 0;
241                    pLFO1->ExtController = 1; // MIDI controller 1
242                    bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);
243                    break;
244                case ::gig::lfo1_ctrl_breath:
245                    lfo1_internal_depth  = 0;
246                    pLFO1->ExtController = 2; // MIDI controller 2
247                    bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);
248                    break;
249                case ::gig::lfo1_ctrl_internal_modwheel:
250                    lfo1_internal_depth  = pRegion->LFO1InternalDepth;
251                    pLFO1->ExtController = 1; // MIDI controller 1
252                    bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);
253                    break;
254                case ::gig::lfo1_ctrl_internal_breath:
255                    lfo1_internal_depth  = pRegion->LFO1InternalDepth;
256                    pLFO1->ExtController = 2; // MIDI controller 2
257                    bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);
258                    break;
259                default:
260                    lfo1_internal_depth  = 0;
261                    pLFO1->ExtController = 0; // no external controller
262                    bLFO1Enabled         = false;
263            }
264            if (bLFO1Enabled) {
265                pLFO1->trigger(pRegion->LFO1Frequency,
266                               start_level_min,
267                               lfo1_internal_depth,
268                               pRegion->LFO1ControlDepth,
269                               pRegion->LFO1FlipPhase,
270                               pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
271                pLFO1->update(pLFO1->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO1->ExtController] : 0);
272          }          }
     #endif // ENABLE_FILTER  
273      }      }
274    
275      #if ENABLE_FILTER      void Voice::InitLFO2() {
276      /**          uint16_t lfo2_internal_depth;
277       * Calculate all necessary, final biquad filter parameters.          switch (pRegion->LFO2Controller) {
278       *              case ::gig::lfo2_ctrl_internal:
279       * @param Samples - number of samples to be rendered in this audio fragment cycle                  lfo2_internal_depth  = pRegion->LFO2InternalDepth;
280       */                  pLFO2->ExtController = 0; // no external controller
281      void Voice::CalculateBiquadParameters(uint Samples) {                  bLFO2Enabled         = (lfo2_internal_depth > 0);
282          if (!FilterLeft.Enabled) return;                  break;
283                case ::gig::lfo2_ctrl_modwheel:
284          biquad_param_t bqbase;                  lfo2_internal_depth  = 0;
285          biquad_param_t bqmain;                  pLFO2->ExtController = 1; // MIDI controller 1
286          float prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][0];                  bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);
287          float prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][0];                  break;
288          FilterLeft.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);              case ::gig::lfo2_ctrl_foot:
289          pEngine->pBasicFilterParameters[0] = bqbase;                  lfo2_internal_depth  = 0;
290          pEngine->pMainFilterParameters[0]  = bqmain;                  pLFO2->ExtController = 4; // MIDI controller 4
291                    bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);
292          float* bq;                  break;
293          for (int i = 1; i < Samples; i++) {              case ::gig::lfo2_ctrl_internal_modwheel:
294              // recalculate biquad parameters if cutoff or resonance differ from previous sample point                  lfo2_internal_depth  = pRegion->LFO2InternalDepth;
295              if (!(i & FILTER_UPDATE_MASK)) if (pEngine->pSynthesisParameters[Event::destination_vcfr][i] != prev_res ||                  pLFO2->ExtController = 1; // MIDI controller 1
296                                                 pEngine->pSynthesisParameters[Event::destination_vcfc][i] != prev_cutoff) {                  bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);
297                  prev_cutoff = pEngine->pSynthesisParameters[Event::destination_vcfc][i];                  break;
298                  prev_res    = pEngine->pSynthesisParameters[Event::destination_vcfr][i];              case ::gig::lfo2_ctrl_internal_foot:
299                  FilterLeft.SetParameters(&bqbase, &bqmain, prev_cutoff, prev_res, pEngine->SampleRate);                  lfo2_internal_depth  = pRegion->LFO2InternalDepth;
300              }                  pLFO2->ExtController = 4; // MIDI controller 4
301                    bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);
302              //same as 'pEngine->pBasicFilterParameters[i] = bqbase;'                  break;
303              bq    = (float*) &pEngine->pBasicFilterParameters[i];              default:
304              bq[0] = bqbase.a1;                  lfo2_internal_depth  = 0;
305              bq[1] = bqbase.a2;                  pLFO2->ExtController = 0; // no external controller
306              bq[2] = bqbase.b0;                  bLFO2Enabled         = false;
307              bq[3] = bqbase.b1;          }
308              bq[4] = bqbase.b2;          if (bLFO2Enabled) {
309                pLFO2->trigger(pRegion->LFO2Frequency,
310              // same as 'pEngine->pMainFilterParameters[i] = bqmain;'                             start_level_max,
311              bq    = (float*) &pEngine->pMainFilterParameters[i];                             lfo2_internal_depth,
312              bq[0] = bqmain.a1;                             pRegion->LFO2ControlDepth,
313              bq[1] = bqmain.a2;                             pRegion->LFO2FlipPhase,
314              bq[2] = bqmain.b0;                             pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
315              bq[3] = bqmain.b1;              pLFO2->update(pLFO2->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO2->ExtController] : 0);
             bq[4] = bqmain.b2;  
316          }          }
317      }      }
     #endif // ENABLE_FILTER  
318    
319      /**      void Voice::InitLFO3() {
320       *  Interpolates the input audio data (no loop).          uint16_t lfo3_internal_depth;
321       *          switch (pRegion->LFO3Controller) {
322       *  @param Samples - number of sample points to be rendered in this audio              case ::gig::lfo3_ctrl_internal:
323       *                   fragment cycle                  lfo3_internal_depth  = pRegion->LFO3InternalDepth;
324       *  @param pSrc    - pointer to input sample data                  pLFO3->ExtController = 0; // no external controller
325       *  @param Skip    - number of sample points to skip in output buffer                  bLFO3Enabled         = (lfo3_internal_depth > 0);
326       */                  break;
327      void Voice::Interpolate(uint Samples, sample_t* pSrc, uint Skip) {              case ::gig::lfo3_ctrl_modwheel:
328          int i = Skip;                  lfo3_internal_depth  = 0;
329                    pLFO3->ExtController = 1; // MIDI controller 1
330          // FIXME: assuming either mono or stereo                  bLFO3Enabled         = (pRegion->LFO3ControlDepth > 0);
331          if (this->pSample->Channels == 2) { // Stereo Sample                  break;
332              while (i < Samples) {              case ::gig::lfo3_ctrl_aftertouch:
333                  InterpolateOneStep_Stereo(pSrc, i,                  lfo3_internal_depth  = 0;
334                                            pEngine->pSynthesisParameters[Event::destination_vca][i],                  pLFO3->ExtController = 128;
335                                            pEngine->pSynthesisParameters[Event::destination_vco][i],                  bLFO3Enabled         = true;
336                                            pEngine->pBasicFilterParameters[i],                  break;
337                                            pEngine->pMainFilterParameters[i]);              case ::gig::lfo3_ctrl_internal_modwheel:
338              }                  lfo3_internal_depth  = pRegion->LFO3InternalDepth;
339                    pLFO3->ExtController = 1; // MIDI controller 1
340                    bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);
341                    break;
342                case ::gig::lfo3_ctrl_internal_aftertouch:
343                    lfo3_internal_depth  = pRegion->LFO3InternalDepth;
344                    pLFO1->ExtController = 128;
345                    bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);
346                    break;
347                default:
348                    lfo3_internal_depth  = 0;
349                    pLFO3->ExtController = 0; // no external controller
350                    bLFO3Enabled         = false;
351            }
352            if (bLFO3Enabled) {
353                pLFO3->trigger(pRegion->LFO3Frequency,
354                               start_level_mid,
355                               lfo3_internal_depth,
356                               pRegion->LFO3ControlDepth,
357                               false,
358                               pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
359                pLFO3->update(pLFO3->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO3->ExtController] : 0);
360            }
361        }
362        
363        float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {
364            float cutoff = pRegion->GetVelocityCutoff(MIDIKeyVelocity);
365            if (pRegion->VCFKeyboardTracking) {
366                cutoff *= exp((MIDIKeyVelocity - pRegion->VCFKeyboardTrackingBreakpoint) * 0.057762265f); // (ln(2) / 12)
367            }
368            return cutoff;
369        }
370    
371        float Voice::CalculateFinalCutoff(float cutoffBase) {
372            int cvalue;
373            if (VCFCutoffCtrl.controller) {
374                cvalue = GetGigEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];
375                if (pRegion->VCFCutoffControllerInvert) cvalue = 127 - cvalue;
376                // VCFVelocityScale in this case means Minimum cutoff
377                if (cvalue < pRegion->VCFVelocityScale) cvalue = pRegion->VCFVelocityScale;
378          }          }
379          else { // Mono Sample          else {
380              while (i < Samples) {              cvalue = pRegion->VCFCutoff;
                 InterpolateOneStep_Mono(pSrc, i,  
                                         pEngine->pSynthesisParameters[Event::destination_vca][i],  
                                         pEngine->pSynthesisParameters[Event::destination_vco][i],  
                                         pEngine->pBasicFilterParameters[i],  
                                         pEngine->pMainFilterParameters[i]);  
             }  
381          }          }
382            float fco = cutoffBase * float(cvalue);
383            if (fco > 127.0f) fco = 127.0f;
384    
385            return fco;
386      }      }
387    
388      /**      uint8_t Voice::GetVCFCutoffCtrl() {
389       *  Interpolates the input audio data, this method honors looping.          uint8_t ctrl;
390       *          switch (pRegion->VCFCutoffController) {
391       *  @param Samples - number of sample points to be rendered in this audio              case ::gig::vcf_cutoff_ctrl_modwheel:
392       *                   fragment cycle                  ctrl = 1;
393       *  @param pSrc    - pointer to input sample data                  break;
394       *  @param Skip    - number of sample points to skip in output buffer              case ::gig::vcf_cutoff_ctrl_effect1:
395       */                  ctrl = 12;
396      void Voice::InterpolateAndLoop(uint Samples, sample_t* pSrc, uint Skip) {                  break;
397          int i = Skip;              case ::gig::vcf_cutoff_ctrl_effect2:
398                    ctrl = 13;
399          // FIXME: assuming either mono or stereo                  break;
400          if (pSample->Channels == 2) { // Stereo Sample              case ::gig::vcf_cutoff_ctrl_breath:
401              if (pSample->LoopPlayCount) {                  ctrl = 2;
402                  // render loop (loop count limited)                  break;
403                  while (i < Samples && LoopCyclesLeft) {              case ::gig::vcf_cutoff_ctrl_foot:
404                      InterpolateOneStep_Stereo(pSrc, i,                  ctrl = 4;
405                                                pEngine->pSynthesisParameters[Event::destination_vca][i],                  break;
406                                                pEngine->pSynthesisParameters[Event::destination_vco][i],              case ::gig::vcf_cutoff_ctrl_sustainpedal:
407                                                pEngine->pBasicFilterParameters[i],                  ctrl = 64;
408                                                pEngine->pMainFilterParameters[i]);                  break;
409                      if (Pos > pSample->LoopEnd) {              case ::gig::vcf_cutoff_ctrl_softpedal:
410                          Pos = pSample->LoopStart + fmod(Pos - pSample->LoopEnd, pSample->LoopSize);;                  ctrl = 67;
411                          LoopCyclesLeft--;                  break;
412                      }              case ::gig::vcf_cutoff_ctrl_genpurpose7:
413                  }                  ctrl = 82;
414                  // render on without loop                  break;
415                  while (i < Samples) {              case ::gig::vcf_cutoff_ctrl_genpurpose8:
416                      InterpolateOneStep_Stereo(pSrc, i,                  ctrl = 83;
417                                                pEngine->pSynthesisParameters[Event::destination_vca][i],                  break;
418                                                pEngine->pSynthesisParameters[Event::destination_vco][i],              case ::gig::vcf_cutoff_ctrl_aftertouch:
419                                                pEngine->pBasicFilterParameters[i],                  ctrl = 128;
420                                                pEngine->pMainFilterParameters[i]);                  break;
421                  }              case ::gig::vcf_cutoff_ctrl_none:
422              }              default:
423              else { // render loop (endless loop)                  ctrl = 0;
424                  while (i < Samples) {                  break;
                     InterpolateOneStep_Stereo(pSrc, i,  
                                               pEngine->pSynthesisParameters[Event::destination_vca][i],  
                                               pEngine->pSynthesisParameters[Event::destination_vco][i],  
                                               pEngine->pBasicFilterParameters[i],  
                                               pEngine->pMainFilterParameters[i]);  
                     if (Pos > pSample->LoopEnd) {  
                         Pos = pSample->LoopStart + fmod(Pos - pSample->LoopEnd, pSample->LoopSize);  
                     }  
                 }  
             }  
         }  
         else { // Mono Sample  
             if (pSample->LoopPlayCount) {  
                 // render loop (loop count limited)  
                 while (i < Samples && LoopCyclesLeft) {  
                     InterpolateOneStep_Mono(pSrc, i,  
                                             pEngine->pSynthesisParameters[Event::destination_vca][i],  
                                             pEngine->pSynthesisParameters[Event::destination_vco][i],  
                                             pEngine->pBasicFilterParameters[i],  
                                             pEngine->pMainFilterParameters[i]);  
                     if (Pos > pSample->LoopEnd) {  
                         Pos = pSample->LoopStart + fmod(Pos - pSample->LoopEnd, pSample->LoopSize);;  
                         LoopCyclesLeft--;  
                     }  
                 }  
                 // render on without loop  
                 while (i < Samples) {  
                     InterpolateOneStep_Mono(pSrc, i,  
                                             pEngine->pSynthesisParameters[Event::destination_vca][i],  
                                             pEngine->pSynthesisParameters[Event::destination_vco][i],  
                                             pEngine->pBasicFilterParameters[i],  
                                             pEngine->pMainFilterParameters[i]);  
                 }  
             }  
             else { // render loop (endless loop)  
                 while (i < Samples) {  
                     InterpolateOneStep_Mono(pSrc, i,  
                                             pEngine->pSynthesisParameters[Event::destination_vca][i],  
                                             pEngine->pSynthesisParameters[Event::destination_vco][i],  
                                             pEngine->pBasicFilterParameters[i],  
                                             pEngine->pMainFilterParameters[i]);  
                     if (Pos > pSample->LoopEnd) {  
                         Pos = pSample->LoopStart + fmod(Pos - pSample->LoopEnd, pSample->LoopSize);;  
                     }  
                 }  
             }  
425          }          }
426    
427            return ctrl;
428      }      }
429    
430      /**      uint8_t Voice::GetVCFResonanceCtrl() {
431       *  Immediately kill the voice. This method should not be used to kill          uint8_t ctrl;
432       *  a normal, active voice, because it doesn't take care of things like          switch (pRegion->VCFResonanceController) {
433       *  fading down the volume level to avoid clicks and regular processing              case ::gig::vcf_res_ctrl_genpurpose3:
434       *  until the kill event actually occured!                  ctrl = 18;
435       *                  break;
436       *  @see Kill()              case ::gig::vcf_res_ctrl_genpurpose4:
437       */                  ctrl = 19;
438      void Voice::KillImmediately() {                  break;
439          if (DiskVoice && DiskStreamRef.State != Stream::state_unused) {              case ::gig::vcf_res_ctrl_genpurpose5:
440              pDiskThread->OrderDeletionOfStream(&DiskStreamRef);                  ctrl = 80;
441                    break;
442                case ::gig::vcf_res_ctrl_genpurpose6:
443                    ctrl = 81;
444                    break;
445                case ::gig::vcf_res_ctrl_none:
446                default:
447                    ctrl = 0;
448          }          }
         Reset();  
     }  
449    
450      /**          return ctrl;
      *  Kill the voice in regular sense. Let the voice render audio until  
      *  the kill event actually occured and then fade down the volume level  
      *  very quickly and let the voice die finally. Unlike a normal release  
      *  of a voice, a kill process cannot be cancalled and is therefore  
      *  usually used for voice stealing and key group conflicts.  
      *  
      *  @param pKillEvent - event which caused the voice to be killed  
      */  
     void Voice::Kill(Event* pKillEvent) {  
         this->pKillEvent = pKillEvent;  
451      }      }
452    
453  }} // namespace LinuxSampler::gig  }} // namespace LinuxSampler::gig
Legend:
Removed from v.239  
changed lines
  Added in v.2015
  ViewVC Help
Powered by ViewVC