/[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 1923 by persson, Sat Jun 27 16:55:41 2009 UTC revision 3625 by schoenebeck, Thu Oct 3 13:37:25 2019 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                       *   *   Copyright (C) 2005 - 2008 Christian Schoenebeck                       *
7     *   Copyright (C) 2009 Christian Schoenebeck and Grigor Iliev             *
8     *   Copyright (C) 2010 - 2017 Christian Schoenebeck and Andreas Persson   *
9   *                                                                         *   *                                                                         *
10   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
11   *   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 24  Line 26 
26  #include "../../common/Features.h"  #include "../../common/Features.h"
27  #include "Synthesizer.h"  #include "Synthesizer.h"
28  #include "Profiler.h"  #include "Profiler.h"
29    #include "Engine.h"
30    #include "EngineChannel.h"
31    
32  #include "Voice.h"  #include "Voice.h"
33    
34  namespace LinuxSampler { namespace gig {  namespace LinuxSampler { namespace gig {
35    
36      Voice::Voice() {      // converts ::gig::lfo_wave_t (libgig) -> LFO::wave_t (LinuxSampler)
37          pEngine     = NULL;      inline LFO::wave_t fromGigLfoWave(::gig::lfo_wave_t wave) {
38          pDiskThread = NULL;          // simply assuming equally mapped enums on both sides
39          PlaybackState = playback_state_end;          return static_cast<LFO::wave_t>(wave);
40          pLFO1 = new LFOUnsigned(1.0f);  // amplitude EG (0..1 range)      }
         pLFO2 = new LFOUnsigned(1.0f);  // filter EG (0..1 range)  
         pLFO3 = new LFOSigned(1200.0f); // pitch EG (-1200..+1200 range)  
         KeyGroup = 0;  
         SynthesisMode = 0; // set all mode bits to 0 first  
         // select synthesis implementation (asm core is not supported ATM)  
         #if 0 // CONFIG_ASM && ARCH_X86  
         SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, Features::supportsMMX() && Features::supportsSSE());  
         #else  
         SYNTHESIS_MODE_SET_IMPLEMENTATION(SynthesisMode, false);  
         #endif  
         SYNTHESIS_MODE_SET_PROFILING(SynthesisMode, Profiler::isEnabled());  
41    
42          finalSynthesisParameters.filterLeft.Reset();      Voice::Voice() {
43          finalSynthesisParameters.filterRight.Reset();          pEngine = NULL;
44            pEG1 = &EG1;
45            pEG2 = &EG2;
46      }      }
47    
48      Voice::~Voice() {      Voice::~Voice() {
         if (pLFO1) delete pLFO1;  
         if (pLFO2) delete pLFO2;  
         if (pLFO3) delete pLFO3;  
49      }      }
50    
51      void Voice::SetEngine(Engine* pEngine) {      EngineChannel* Voice::GetGigEngineChannel() {
52          this->pEngine     = pEngine;          return static_cast<EngineChannel*>(pEngineChannel);
         this->pDiskThread = pEngine->pDiskThread;  
         dmsg(6,("Voice::SetEngine()\n"));  
53      }      }
54    
55      /**      void Voice::SetEngine(LinuxSampler::Engine* pEngine) {
56       *  Initializes and triggers the voice, a disk stream will be launched if          Engine* engine = static_cast<Engine*>(pEngine);
57       *  needed.          this->pEngine     = engine;
58       *          this->pDiskThread = engine->pDiskThread;
59       *  @param pEngineChannel - engine channel on which this voice was ordered          dmsg(6,("Voice::SetEngine()\n"));
60       *  @param itNoteOnEvent  - event that caused triggering of this voice      }
      *  @param PitchBend      - MIDI detune factor (-8192 ... +8191)  
      *  @param pDimRgn        - points to the dimension region which provides sample wave(s) and articulation data  
      *  @param VoiceType      - type of this voice  
      *  @param iKeyGroup      - a value > 0 defines a key group in which this voice is member of  
      *  @returns 0 on success, a value < 0 if the voice wasn't triggered  
      *           (either due to an error or e.g. because no region is  
      *           defined for the given key)  
      */  
     int Voice::Trigger(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent, int PitchBend, ::gig::DimensionRegion* pDimRgn, type_t VoiceType, int iKeyGroup) {  
         this->pEngineChannel = pEngineChannel;  
         this->pDimRgn        = pDimRgn;  
         Orphan = false;  
   
         #if CONFIG_DEVMODE  
         if (itNoteOnEvent->FragmentPos() > pEngine->MaxSamplesPerCycle) { // just a sanity check for debugging  
             dmsg(1,("Voice::Trigger(): ERROR, TriggerDelay > Totalsamples\n"));  
         }  
         #endif // CONFIG_DEVMODE  
   
         Type            = VoiceType;  
         MIDIKey         = itNoteOnEvent->Param.Note.Key;  
         PlaybackState   = playback_state_init; // mark voice as triggered, but no audio rendered yet  
         Delay           = itNoteOnEvent->FragmentPos();  
         itTriggerEvent  = itNoteOnEvent;  
         itKillEvent     = Pool<Event>::Iterator();  
         KeyGroup        = iKeyGroup;  
         pSample         = pDimRgn->pSample; // sample won't change until the voice is finished  
   
         // calculate volume  
         const double velocityAttenuation = pDimRgn->GetVelocityAttenuation(itNoteOnEvent->Param.Note.Velocity);  
   
         // For 16 bit samples, we downscale by 32768 to convert from  
         // int16 value range to DSP value range (which is  
         // -1.0..1.0). For 24 bit, we downscale from int32.  
         float volume = velocityAttenuation / (pSample->BitDepth == 16 ? 32768.0f : 32768.0f * 65536.0f);  
   
         volume *= pDimRgn->SampleAttenuation * pEngineChannel->GlobalVolume * GLOBAL_VOLUME;  
   
         // the volume of release triggered samples depends on note length  
         if (Type == type_release_trigger) {  
             float noteLength = float(pEngine->FrameTime + Delay -  
                                      pEngineChannel->pMIDIKeyInfo[MIDIKey].NoteOnTime) / pEngine->SampleRate;  
             float attenuation = 1 - 0.01053 * (256 >> pDimRgn->ReleaseTriggerDecay) * noteLength;  
             if (attenuation <= 0) return -1;  
             volume *= attenuation;  
         }  
   
         // select channel mode (mono or stereo)  
         SYNTHESIS_MODE_SET_CHANNELS(SynthesisMode, pSample->Channels == 2);  
         // select bit depth (16 or 24)  
         SYNTHESIS_MODE_SET_BITDEPTH24(SynthesisMode, pSample->BitDepth == 24);  
   
         // get starting crossfade volume level  
         float crossfadeVolume;  
         switch (pDimRgn->AttenuationController.type) {  
             case ::gig::attenuation_ctrl_t::type_channelaftertouch:  
                 crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(pEngineChannel->ControllerTable[128])];  
                 break;  
             case ::gig::attenuation_ctrl_t::type_velocity:  
                 crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(itNoteOnEvent->Param.Note.Velocity)];  
                 break;  
             case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate  
                 crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(pEngineChannel->ControllerTable[pDimRgn->AttenuationController.controller_number])];  
                 break;  
             case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined  
             default:  
                 crossfadeVolume = 1.0f;  
         }  
   
         VolumeLeft  = volume * Engine::PanCurve[64 - pDimRgn->Pan];  
         VolumeRight = volume * Engine::PanCurve[64 + pDimRgn->Pan];  
   
         float subfragmentRate = pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;  
         CrossfadeSmoother.trigger(crossfadeVolume, subfragmentRate);  
         VolumeSmoother.trigger(pEngineChannel->MidiVolume, subfragmentRate);  
         PanLeftSmoother.trigger(pEngineChannel->GlobalPanLeft, subfragmentRate);  
         PanRightSmoother.trigger(pEngineChannel->GlobalPanRight, subfragmentRate);  
   
         finalSynthesisParameters.dPos = pDimRgn->SampleStartOffset; // offset where we should start playback of sample (0 - 2000 sample points)  
         Pos = pDimRgn->SampleStartOffset;  
   
         // Check if the sample needs disk streaming or is too short for that  
         long cachedsamples = pSample->GetCache().Size / pSample->FrameSize;  
         DiskVoice          = cachedsamples < pSample->SamplesTotal;  
   
         const DLS::sample_loop_t& loopinfo = pDimRgn->pSampleLoops[0];  
   
         if (DiskVoice) { // voice to be streamed from disk  
             if (cachedsamples > (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH)) {  
                 MaxRAMPos = cachedsamples - (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH) / pSample->Channels; //TODO: this calculation is too pessimistic and may better be moved to Render() method, so it calculates MaxRAMPos dependent to the current demand of sample points to be rendered (e.g. in case of JACK)  
             } else {  
                 // The cache is too small to fit a max sample buffer.  
                 // Setting MaxRAMPos to 0 will probably cause a click  
                 // in the audio, but it's better than not handling  
                 // this case at all, which would have caused the  
                 // unsigned MaxRAMPos to be set to a negative number.  
                 MaxRAMPos = 0;  
             }  
   
             // check if there's a loop defined which completely fits into the cached (RAM) part of the sample  
             RAMLoop = (pDimRgn->SampleLoops && (loopinfo.LoopStart + loopinfo.LoopLength) <= MaxRAMPos);  
   
             if (pDiskThread->OrderNewStream(&DiskStreamRef, pDimRgn, MaxRAMPos, !RAMLoop) < 0) {  
                 dmsg(1,("Disk stream order failed!\n"));  
                 KillImmediately();  
                 return -1;  
             }  
             dmsg(4,("Disk voice launched (cached samples: %d, total Samples: %d, MaxRAMPos: %d, RAMLooping: %s)\n", cachedsamples, pSample->SamplesTotal, MaxRAMPos, (RAMLoop) ? "yes" : "no"));  
         }  
         else { // RAM only voice  
             MaxRAMPos = cachedsamples;  
             RAMLoop = (pDimRgn->SampleLoops != 0);  
             dmsg(4,("RAM only voice launched (Looping: %s)\n", (RAMLoop) ? "yes" : "no"));  
         }  
         if (RAMLoop) {  
             loop.uiTotalCycles = pSample->LoopPlayCount;  
             loop.uiCyclesLeft  = pSample->LoopPlayCount;  
             loop.uiStart       = loopinfo.LoopStart;  
             loop.uiEnd         = loopinfo.LoopStart + loopinfo.LoopLength;  
             loop.uiSize        = loopinfo.LoopLength;  
         }  
   
         // calculate initial pitch value  
         {  
             double pitchbasecents = pEngineChannel->pInstrument->FineTune + pDimRgn->FineTune + pEngine->ScaleTuning[MIDIKey % 12];  
   
             // GSt behaviour: maximum transpose up is 40 semitones. If  
             // MIDI key is more than 40 semitones above unity note,  
             // the transpose is not done.  
             if (pDimRgn->PitchTrack && (MIDIKey - (int) pDimRgn->UnityNote) < 40) pitchbasecents += (MIDIKey - (int) pDimRgn->UnityNote) * 100;  
   
             this->PitchBase = RTMath::CentsToFreqRatioUnlimited(pitchbasecents) * (double(pSample->SamplesPerSecond) / double(pEngine->SampleRate));  
             this->PitchBendRange = 1.0 / 8192.0 * 100.0 * pEngineChannel->pInstrument->PitchbendRange;  
             this->PitchBend = RTMath::CentsToFreqRatio(PitchBend * PitchBendRange);  
         }  
   
         // the length of the decay and release curves are dependent on the velocity  
         const double velrelease = 1 / pDimRgn->GetVelocityRelease(itNoteOnEvent->Param.Note.Velocity);  
   
         // setup EG 1 (VCA EG)  
         {  
             // get current value of EG1 controller  
             double eg1controllervalue;  
             switch (pDimRgn->EG1Controller.type) {  
                 case ::gig::eg1_ctrl_t::type_none: // no controller defined  
                     eg1controllervalue = 0;  
                     break;  
                 case ::gig::eg1_ctrl_t::type_channelaftertouch:  
                     eg1controllervalue = pEngineChannel->ControllerTable[128];  
                     break;  
                 case ::gig::eg1_ctrl_t::type_velocity:  
                     eg1controllervalue = itNoteOnEvent->Param.Note.Velocity;  
                     break;  
                 case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller  
                     eg1controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG1Controller.controller_number];  
                     break;  
             }  
             if (pDimRgn->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;  
   
             // calculate influence of EG1 controller on EG1's parameters  
             // (eg1attack is different from the others)  
             double eg1attack  = (pDimRgn->EG1ControllerAttackInfluence)  ?  
                 1 + 0.031 * (double) (pDimRgn->EG1ControllerAttackInfluence == 1 ?  
                                       1 : 1 << pDimRgn->EG1ControllerAttackInfluence) * eg1controllervalue : 1.0;  
             double eg1decay   = (pDimRgn->EG1ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerDecayInfluence)   * eg1controllervalue : 1.0;  
             double eg1release = (pDimRgn->EG1ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG1ControllerReleaseInfluence) * eg1controllervalue : 1.0;  
   
             EG1.trigger(pDimRgn->EG1PreAttack,  
                         pDimRgn->EG1Attack * eg1attack,  
                         pDimRgn->EG1Hold,  
                         pDimRgn->EG1Decay1 * eg1decay * velrelease,  
                         pDimRgn->EG1Decay2 * eg1decay * velrelease,  
                         pDimRgn->EG1InfiniteSustain,  
                         pDimRgn->EG1Sustain,  
                         pDimRgn->EG1Release * eg1release * velrelease,  
                         velocityAttenuation,  
                         pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
         }  
   
 #ifdef CONFIG_INTERPOLATE_VOLUME  
         // setup initial volume in synthesis parameters  
 #ifdef CONFIG_PROCESS_MUTED_CHANNELS  
         if (pEngineChannel->GetMute()) {  
             finalSynthesisParameters.fFinalVolumeLeft  = 0;  
             finalSynthesisParameters.fFinalVolumeRight = 0;  
         }  
         else  
 #else  
         {  
             float finalVolume = pEngineChannel->MidiVolume * crossfadeVolume * EG1.getLevel();  
   
             finalSynthesisParameters.fFinalVolumeLeft  = finalVolume * VolumeLeft  * pEngineChannel->GlobalPanLeft;  
             finalSynthesisParameters.fFinalVolumeRight = finalVolume * VolumeRight * pEngineChannel->GlobalPanRight;  
         }  
 #endif  
 #endif  
   
         // setup EG 2 (VCF Cutoff EG)  
         {  
             // get current value of EG2 controller  
             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 = pEngineChannel->ControllerTable[128];  
                     break;  
                 case ::gig::eg2_ctrl_t::type_velocity:  
                     eg2controllervalue = itNoteOnEvent->Param.Note.Velocity;  
                     break;  
                 case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller  
                     eg2controllervalue = pEngineChannel->ControllerTable[pDimRgn->EG2Controller.controller_number];  
                     break;  
             }  
             if (pDimRgn->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;  
61    
62              // calculate influence of EG2 controller on EG2's parameters      Voice::SampleInfo Voice::GetSampleInfo() {
63              double eg2attack  = (pDimRgn->EG2ControllerAttackInfluence)  ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerAttackInfluence)  * eg2controllervalue : 1.0;          SampleInfo si;
64              double eg2decay   = (pDimRgn->EG2ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerDecayInfluence)   * eg2controllervalue : 1.0;          si.SampleRate       = pSample->SamplesPerSecond;
65              double eg2release = (pDimRgn->EG2ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pDimRgn->EG2ControllerReleaseInfluence) * eg2controllervalue : 1.0;          si.ChannelCount     = pSample->Channels;
66            si.FrameSize        = pSample->FrameSize;
67              EG2.trigger(pDimRgn->EG2PreAttack,          si.BitDepth         = pSample->BitDepth;
68                          pDimRgn->EG2Attack * eg2attack,          si.TotalFrameCount  = (uint)pSample->SamplesTotal;
                         false,  
                         pDimRgn->EG2Decay1 * eg2decay * velrelease,  
                         pDimRgn->EG2Decay2 * eg2decay * velrelease,  
                         pDimRgn->EG2InfiniteSustain,  
                         pDimRgn->EG2Sustain,  
                         pDimRgn->EG2Release * eg2release * velrelease,  
                         velocityAttenuation,  
                         pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
         }  
   
   
         // setup EG 3 (VCO EG)  
         {  
             // if portamento mode is on, we dedicate EG3 purely for portamento, otherwise if portamento is off we do as told by the patch  
             bool  bPortamento = pEngineChannel->PortamentoMode && pEngineChannel->PortamentoPos >= 0.0f;  
             float eg3depth = (bPortamento)  
                                  ? RTMath::CentsToFreqRatio((pEngineChannel->PortamentoPos - (float) MIDIKey) * 100)  
                                  : RTMath::CentsToFreqRatio(pDimRgn->EG3Depth);  
             float eg3time = (bPortamento)  
                                 ? pEngineChannel->PortamentoTime  
                                 : pDimRgn->EG3Attack;  
             EG3.trigger(eg3depth, eg3time, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
             dmsg(5,("PortamentoPos=%f, depth=%f, time=%f\n", pEngineChannel->PortamentoPos, eg3depth, eg3time));  
         }  
   
   
         // setup LFO 1 (VCA LFO)  
         {  
             uint16_t lfo1_internal_depth;  
             switch (pDimRgn->LFO1Controller) {  
                 case ::gig::lfo1_ctrl_internal:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 0; // no external controller  
                     bLFO1Enabled         = (lfo1_internal_depth > 0);  
                     break;  
                 case ::gig::lfo1_ctrl_modwheel:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 1; // MIDI controller 1  
                     bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);  
                     break;  
                 case ::gig::lfo1_ctrl_breath:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 2; // MIDI controller 2  
                     bLFO1Enabled         = (pDimRgn->LFO1ControlDepth > 0);  
                     break;  
                 case ::gig::lfo1_ctrl_internal_modwheel:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 1; // MIDI controller 1  
                     bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);  
                     break;  
                 case ::gig::lfo1_ctrl_internal_breath:  
                     lfo1_internal_depth  = pDimRgn->LFO1InternalDepth;  
                     pLFO1->ExtController = 2; // MIDI controller 2  
                     bLFO1Enabled         = (lfo1_internal_depth > 0 || pDimRgn->LFO1ControlDepth > 0);  
                     break;  
                 default:  
                     lfo1_internal_depth  = 0;  
                     pLFO1->ExtController = 0; // no external controller  
                     bLFO1Enabled         = false;  
             }  
             if (bLFO1Enabled) {  
                 pLFO1->trigger(pDimRgn->LFO1Frequency,  
                                start_level_min,  
                                lfo1_internal_depth,  
                                pDimRgn->LFO1ControlDepth,  
                                pDimRgn->LFO1FlipPhase,  
                                pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 pLFO1->update(pLFO1->ExtController ? pEngineChannel->ControllerTable[pLFO1->ExtController] : 0);  
             }  
         }  
69    
70            si.HasLoops       = pRegion->SampleLoops;
71            si.LoopStart      = (si.HasLoops) ? pRegion->pSampleLoops[0].LoopStart  : 0;
72            si.LoopLength     = (si.HasLoops) ? pRegion->pSampleLoops[0].LoopLength : 0;
73            si.LoopPlayCount  = pSample->LoopPlayCount;
74            si.Unpitched      = !pRegion->PitchTrack;
75    
76          // setup LFO 2 (VCF Cutoff LFO)          return si;
77          {      }
             uint16_t lfo2_internal_depth;  
             switch (pDimRgn->LFO2Controller) {  
                 case ::gig::lfo2_ctrl_internal:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 0; // no external controller  
                     bLFO2Enabled         = (lfo2_internal_depth > 0);  
                     break;  
                 case ::gig::lfo2_ctrl_modwheel:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 1; // MIDI controller 1  
                     bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);  
                     break;  
                 case ::gig::lfo2_ctrl_foot:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 4; // MIDI controller 4  
                     bLFO2Enabled         = (pDimRgn->LFO2ControlDepth > 0);  
                     break;  
                 case ::gig::lfo2_ctrl_internal_modwheel:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 1; // MIDI controller 1  
                     bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);  
                     break;  
                 case ::gig::lfo2_ctrl_internal_foot:  
                     lfo2_internal_depth  = pDimRgn->LFO2InternalDepth;  
                     pLFO2->ExtController = 4; // MIDI controller 4  
                     bLFO2Enabled         = (lfo2_internal_depth > 0 || pDimRgn->LFO2ControlDepth > 0);  
                     break;  
                 default:  
                     lfo2_internal_depth  = 0;  
                     pLFO2->ExtController = 0; // no external controller  
                     bLFO2Enabled         = false;  
             }  
             if (bLFO2Enabled) {  
                 pLFO2->trigger(pDimRgn->LFO2Frequency,  
                                start_level_max,  
                                lfo2_internal_depth,  
                                pDimRgn->LFO2ControlDepth,  
                                pDimRgn->LFO2FlipPhase,  
                                pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 pLFO2->update(pLFO2->ExtController ? pEngineChannel->ControllerTable[pLFO2->ExtController] : 0);  
             }  
         }  
78    
79        Voice::RegionInfo Voice::GetRegionInfo() {
80            RegionInfo ri;
81            ri.UnityNote = pRegion->UnityNote;
82            ri.FineTune  = pRegion->FineTune;
83            ri.Pan       = pRegion->Pan;
84            ri.SampleStartOffset = pRegion->SampleStartOffset;
85    
86          // setup LFO 3 (VCO LFO)          ri.EG2PreAttack        = pRegion->EG2PreAttack;
87          {          ri.EG2Attack           = pRegion->EG2Attack;
88              uint16_t lfo3_internal_depth;          ri.EG2Decay1           = pRegion->EG2Decay1;
89              switch (pDimRgn->LFO3Controller) {          ri.EG2Decay2           = pRegion->EG2Decay2;
90                  case ::gig::lfo3_ctrl_internal:          ri.EG2Sustain          = pRegion->EG2Sustain;
91                      lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;          ri.EG2InfiniteSustain  = pRegion->EG2InfiniteSustain;
92                      pLFO3->ExtController = 0; // no external controller          ri.EG2Release          = pRegion->EG2Release;
                     bLFO3Enabled         = (lfo3_internal_depth > 0);  
                     break;  
                 case ::gig::lfo3_ctrl_modwheel:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 1; // MIDI controller 1  
                     bLFO3Enabled         = (pDimRgn->LFO3ControlDepth > 0);  
                     break;  
                 case ::gig::lfo3_ctrl_aftertouch:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 128;  
                     bLFO3Enabled         = true;  
                     break;  
                 case ::gig::lfo3_ctrl_internal_modwheel:  
                     lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;  
                     pLFO3->ExtController = 1; // MIDI controller 1  
                     bLFO3Enabled         = (lfo3_internal_depth > 0 || pDimRgn->LFO3ControlDepth > 0);  
                     break;  
                 case ::gig::lfo3_ctrl_internal_aftertouch:  
                     lfo3_internal_depth  = pDimRgn->LFO3InternalDepth;  
                     pLFO1->ExtController = 128;  
                     bLFO3Enabled         = (lfo3_internal_depth > 0 || pDimRgn->LFO3ControlDepth > 0);  
                     break;  
                 default:  
                     lfo3_internal_depth  = 0;  
                     pLFO3->ExtController = 0; // no external controller  
                     bLFO3Enabled         = false;  
             }  
             if (bLFO3Enabled) {  
                 pLFO3->trigger(pDimRgn->LFO3Frequency,  
                                start_level_mid,  
                                lfo3_internal_depth,  
                                pDimRgn->LFO3ControlDepth,  
                                false,  
                                pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 pLFO3->update(pLFO3->ExtController ? pEngineChannel->ControllerTable[pLFO3->ExtController] : 0);  
             }  
         }  
93    
94            ri.EG3Attack     = pRegion->EG3Attack;
95            ri.EG3Depth      = pRegion->EG3Depth;
96            ri.VCFEnabled    = pRegion->VCFEnabled;
97            ri.VCFType       = Filter::vcf_type_t(pRegion->VCFType);
98            ri.VCFResonance  = pRegion->VCFResonance;
99    
100          #if CONFIG_FORCE_FILTER          ri.ReleaseTriggerDecay = 0.01053 * (256 >> pRegion->ReleaseTriggerDecay);
         const bool bUseFilter = true;  
         #else // use filter only if instrument file told so  
         const bool bUseFilter = pDimRgn->VCFEnabled;  
         #endif // CONFIG_FORCE_FILTER  
         SYNTHESIS_MODE_SET_FILTER(SynthesisMode, bUseFilter);  
         if (bUseFilter) {  
             #ifdef CONFIG_OVERRIDE_CUTOFF_CTRL  
             VCFCutoffCtrl.controller = CONFIG_OVERRIDE_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:  
                     VCFCutoffCtrl.controller = 128;  
                     break;  
                 case ::gig::vcf_cutoff_ctrl_none:  
                 default:  
                     VCFCutoffCtrl.controller = 0;  
                     break;  
             }  
             #endif // CONFIG_OVERRIDE_CUTOFF_CTRL  
101    
102              #ifdef CONFIG_OVERRIDE_RESONANCE_CTRL          return ri;
103              VCFResonanceCtrl.controller = CONFIG_OVERRIDE_RESONANCE_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 // CONFIG_OVERRIDE_RESONANCE_CTRL  
104    
105              #ifndef CONFIG_OVERRIDE_FILTER_TYPE      Voice::InstrumentInfo Voice::GetInstrumentInfo() {
106              finalSynthesisParameters.filterLeft.SetType(pDimRgn->VCFType);          InstrumentInfo ii;
107              finalSynthesisParameters.filterRight.SetType(pDimRgn->VCFType);          ii.FineTune = GetGigEngineChannel()->pInstrument->FineTune;
108              #else // override filter type          ii.PitchbendRange = GetGigEngineChannel()->pInstrument->PitchbendRange;
             finalSynthesisParameters.filterLeft.SetType(CONFIG_OVERRIDE_FILTER_TYPE);  
             finalSynthesisParameters.filterRight.SetType(CONFIG_OVERRIDE_FILTER_TYPE);  
             #endif // CONFIG_OVERRIDE_FILTER_TYPE  
   
             VCFCutoffCtrl.value    = pEngineChannel->ControllerTable[VCFCutoffCtrl.controller];  
             VCFResonanceCtrl.value = pEngineChannel->ControllerTable[VCFResonanceCtrl.controller];  
   
             // calculate cutoff frequency  
             float cutoff = pDimRgn->GetVelocityCutoff(itNoteOnEvent->Param.Note.Velocity);  
             if (pDimRgn->VCFKeyboardTracking) {  
                 cutoff *= exp((itNoteOnEvent->Param.Note.Key - pDimRgn->VCFKeyboardTrackingBreakpoint) * 0.057762265f); // (ln(2) / 12)  
             }  
             CutoffBase = cutoff;  
109    
110              int cvalue;          return ii;
111              if (VCFCutoffCtrl.controller) {      }
                 cvalue = pEngineChannel->ControllerTable[VCFCutoffCtrl.controller];  
                 if (pDimRgn->VCFCutoffControllerInvert) cvalue = 127 - cvalue;  
                 // VCFVelocityScale in this case means Minimum cutoff  
                 if (cvalue < pDimRgn->VCFVelocityScale) cvalue = pDimRgn->VCFVelocityScale;  
             }  
             else {  
                 cvalue = pDimRgn->VCFCutoff;  
             }  
             cutoff *= float(cvalue);  
             if (cutoff > 127.0f) cutoff = 127.0f;  
112    
113              // calculate resonance      double Voice::GetSampleAttenuation() {
114              float resonance = (float) (VCFResonanceCtrl.controller ? VCFResonanceCtrl.value : pDimRgn->VCFResonance);          return pRegion->SampleAttenuation;
115        }
116    
117              VCFCutoffCtrl.fvalue    = cutoff;      double Voice::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
118              VCFResonanceCtrl.fvalue = resonance;          return pRegion->GetVelocityAttenuation(MIDIKeyVelocity);
119          }      }
         else {  
             VCFCutoffCtrl.controller    = 0;  
             VCFResonanceCtrl.controller = 0;  
         }  
120    
121          return 0; // success      double Voice::GetVelocityRelease(uint8_t MIDIKeyVelocity) {
122            return pRegion->GetVelocityRelease(MIDIKeyVelocity);
123      }      }
124    
125      /**      void Voice::ProcessCCEvent(RTList<Event>::Iterator& itEvent) {
126       *  Renders the audio data for this voice for the current audio fragment.          if (itEvent->Type == Event::type_control_change && itEvent->Param.CC.Controller) { // if (valid) MIDI control change event
127       *  The sample input data can either come from RAM (cached sample or sample              if (pRegion->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&
128       *  part) or directly from disk. The output signal will be rendered by                  itEvent->Param.CC.Controller == pRegion->AttenuationController.controller_number) {
129       *  resampling / interpolation. If this voice is a disk streaming voice and                  CrossfadeSmoother.update(AbstractEngine::CrossfadeCurve[CrossfadeAttenuation(itEvent->Param.CC.Value)]);
      *  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) {  
   
         // select default values for synthesis mode bits  
         SYNTHESIS_MODE_SET_LOOP(SynthesisMode, false);  
   
         switch (this->PlaybackState) {  
   
             case playback_state_init:  
                 this->PlaybackState = playback_state_ram; // we always start playback from RAM cache and switch then to disk if needed  
                 // no break - continue with playback_state_ram  
   
             case playback_state_ram: {  
                     if (RAMLoop) SYNTHESIS_MODE_SET_LOOP(SynthesisMode, true); // enable looping  
   
                     // render current fragment  
                     Synthesize(Samples, (sample_t*) pSample->GetCache().pStart, Delay);  
   
                     if (DiskVoice) {  
                         // check if we reached the allowed limit of the sample RAM cache  
                         if (finalSynthesisParameters.dPos > MaxRAMPos) {  
                             dmsg(5,("Voice: switching to disk playback (Pos=%f)\n", finalSynthesisParameters.dPos));  
                             this->PlaybackState = playback_state_disk;  
                         }  
                     } else if (finalSynthesisParameters.dPos >= 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 * (int(finalSynthesisParameters.dPos) - MaxRAMPos));  
                         finalSynthesisParameters.dPos -= int(finalSynthesisParameters.dPos);  
                         RealSampleWordsLeftToRead = -1; // -1 means no silence has been added yet  
                     }  
   
                     const int sampleWordsLeftToRead = DiskStreamRef.pStream->GetReadSpace();  
   
                     // add silence sample at the end if we reached the end of the stream (for the interpolator)  
                     if (DiskStreamRef.State == Stream::state_end) {  
                         const int maxSampleWordsPerCycle = (pEngine->MaxSamplesPerCycle << CONFIG_MAX_PITCH) * pSample->Channels + 6; // +6 for the interpolator algorithm  
                         if (sampleWordsLeftToRead <= maxSampleWordsPerCycle) {  
                             // remember how many sample words there are before any silence has been added  
                             if (RealSampleWordsLeftToRead < 0) RealSampleWordsLeftToRead = sampleWordsLeftToRead;  
                             DiskStreamRef.pStream->WriteSilence(maxSampleWordsPerCycle - sampleWordsLeftToRead);  
                         }  
                     }  
   
                     sample_t* ptr = (sample_t*)DiskStreamRef.pStream->GetReadPtr(); // get the current read_ptr within the ringbuffer where we read the samples from  
   
                     // render current audio fragment  
                     Synthesize(Samples, ptr, Delay);  
   
                     const int iPos = (int) finalSynthesisParameters.dPos;  
                     const int readSampleWords = iPos * pSample->Channels; // amount of sample words actually been read  
                     DiskStreamRef.pStream->IncrementReadPos(readSampleWords);  
                     finalSynthesisParameters.dPos -= iPos; // just keep fractional part of playback position  
   
                     // change state of voice to 'end' if we really reached the end of the sample data  
                     if (RealSampleWordsLeftToRead >= 0) {  
                         RealSampleWordsLeftToRead -= readSampleWords;  
                         if (RealSampleWordsLeftToRead <= 0) this->PlaybackState = playback_state_end;  
                     }  
                 }  
                 break;  
   
             case playback_state_end:  
                 std::cerr << "gig::Voice::Render(): entered with playback_state_end, this is a bug!\n" << std::flush;  
                 break;  
         }  
   
         // Reset delay  
         Delay = 0;  
   
         itTriggerEvent = Pool<Event>::Iterator();  
   
         // If sample stream or release stage finished, kill the voice  
         if (PlaybackState == playback_state_end || EG1.getSegmentType() == EGADSR::segment_end) KillImmediately();  
     }  
   
     /**  
      *  Resets voice variables. Should only be called if rendering process is  
      *  suspended / not running.  
      */  
     void Voice::Reset() {  
         finalSynthesisParameters.filterLeft.Reset();  
         finalSynthesisParameters.filterRight.Reset();  
         DiskStreamRef.pStream = NULL;  
         DiskStreamRef.hStream = 0;  
         DiskStreamRef.State   = Stream::state_unused;  
         DiskStreamRef.OrderID = 0;  
         PlaybackState = playback_state_end;  
         itTriggerEvent = Pool<Event>::Iterator();  
         itKillEvent    = Pool<Event>::Iterator();  
     }  
   
     /**  
      * Process given list of MIDI note on, note off and sustain pedal events  
      * for the given time.  
      *  
      * @param itEvent - iterator pointing to the next event to be processed  
      * @param End     - youngest time stamp where processing should be stopped  
      */  
     void Voice::processTransitionEvents(RTList<Event>::Iterator& itEvent, uint End) {  
         for (; itEvent && itEvent->FragmentPos() <= End; ++itEvent) {  
             if (itEvent->Type == Event::type_release) {  
                 EG1.update(EGADSR::event_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 EG2.update(EGADSR::event_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
             } else if (itEvent->Type == Event::type_cancel_release) {  
                 EG1.update(EGADSR::event_cancel_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 EG2.update(EGADSR::event_cancel_release, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
130              }              }
131          }          }
132      }      }
133    
134      /**      void Voice::ProcessChannelPressureEvent(RTList<Event>::Iterator& itEvent) {
135       * Process given list of MIDI control change and pitch bend events for          if (itEvent->Type == Event::type_channel_pressure) { // if (valid) MIDI channel pressure (aftertouch) event
136       * the given time.              if (pRegion->AttenuationController.type == ::gig::attenuation_ctrl_t::type_channelaftertouch) {
137       *                  CrossfadeSmoother.update(AbstractEngine::CrossfadeCurve[CrossfadeAttenuation(itEvent->Param.ChannelPressure.Value)]);
      * @param itEvent - iterator pointing to the next event to be processed  
      * @param End     - youngest time stamp where processing should be stopped  
      */  
     void Voice::processCCEvents(RTList<Event>::Iterator& itEvent, uint End) {  
         for (; itEvent && itEvent->FragmentPos() <= End; ++itEvent) {  
             if (itEvent->Type == Event::type_control_change &&  
                 itEvent->Param.CC.Controller) { // if (valid) MIDI control change event  
                 if (itEvent->Param.CC.Controller == VCFCutoffCtrl.controller) {  
                     processCutoffEvent(itEvent);  
                 }  
                 if (itEvent->Param.CC.Controller == VCFResonanceCtrl.controller) {  
                     processResonanceEvent(itEvent);  
                 }  
                 if (itEvent->Param.CC.Controller == pLFO1->ExtController) {  
                     pLFO1->update(itEvent->Param.CC.Value);  
                 }  
                 if (itEvent->Param.CC.Controller == pLFO2->ExtController) {  
                     pLFO2->update(itEvent->Param.CC.Value);  
                 }  
                 if (itEvent->Param.CC.Controller == pLFO3->ExtController) {  
                     pLFO3->update(itEvent->Param.CC.Value);  
                 }  
                 if (pDimRgn->AttenuationController.type == ::gig::attenuation_ctrl_t::type_controlchange &&  
                     itEvent->Param.CC.Controller == pDimRgn->AttenuationController.controller_number) {  
                     CrossfadeSmoother.update(Engine::CrossfadeCurve[CrossfadeAttenuation(itEvent->Param.CC.Value)]);  
                 }  
                 if (itEvent->Param.CC.Controller == 7) { // volume  
                     VolumeSmoother.update(Engine::VolumeCurve[itEvent->Param.CC.Value]);  
                 } else if (itEvent->Param.CC.Controller == 10) { // panpot  
                     PanLeftSmoother.update(Engine::PanCurve[128 - itEvent->Param.CC.Value]);  
                     PanRightSmoother.update(Engine::PanCurve[itEvent->Param.CC.Value]);  
                 }  
             } else if (itEvent->Type == Event::type_pitchbend) { // if pitch bend event  
                 processPitchEvent(itEvent);  
138              }              }
139          }          }
140      }      }
141    
142      void Voice::processPitchEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessPolyphonicKeyPressureEvent(RTList<Event>::Iterator& itEvent) {
143          PitchBend = RTMath::CentsToFreqRatio(itEvent->Param.Pitch.Pitch * PitchBendRange);          // Not used so far
144      }      }
145    
146      void Voice::processCutoffEvent(RTList<Event>::Iterator& itEvent) {      void Voice::ProcessCutoffEvent(RTList<Event>::Iterator& itEvent) {
147          int ccvalue = itEvent->Param.CC.Value;          int ccvalue = itEvent->Param.CC.Value;
148          if (VCFCutoffCtrl.value == ccvalue) return;          if (VCFCutoffCtrl.value == ccvalue) return;
149          VCFCutoffCtrl.value == ccvalue;          VCFCutoffCtrl.value = ccvalue;
150          if (pDimRgn->VCFCutoffControllerInvert)  ccvalue = 127 - ccvalue;          if (pRegion->VCFCutoffControllerInvert)  ccvalue = 127 - ccvalue;
151          if (ccvalue < pDimRgn->VCFVelocityScale) ccvalue = pDimRgn->VCFVelocityScale;          if (ccvalue < pRegion->VCFVelocityScale) ccvalue = pRegion->VCFVelocityScale;
152          float cutoff = CutoffBase * float(ccvalue);          float cutoff = CutoffBase * float(ccvalue);
153          if (cutoff > 127.0f) cutoff = 127.0f;          if (cutoff > 127.0f) cutoff = 127.0f;
154    
# Line 763  namespace LinuxSampler { namespace gig { Line 156  namespace LinuxSampler { namespace gig {
156          fFinalCutoff = cutoff;          fFinalCutoff = cutoff;
157      }      }
158    
159      void Voice::processResonanceEvent(RTList<Event>::Iterator& itEvent) {      double Voice::CalculateCrossfadeVolume(uint8_t MIDIKeyVelocity) {
160          // convert absolute controller value to differential          float crossfadeVolume;
161          const int ctrldelta = itEvent->Param.CC.Value - VCFResonanceCtrl.value;          switch (pRegion->AttenuationController.type) {
162          VCFResonanceCtrl.value = itEvent->Param.CC.Value;              case ::gig::attenuation_ctrl_t::type_channelaftertouch:
163          const float resonancedelta = (float) ctrldelta;                  crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(GetGigEngineChannel()->ControllerTable[128])];
164          fFinalResonance += resonancedelta;                  break;
165          // needed for initialization of parameter              case ::gig::attenuation_ctrl_t::type_velocity:
166          VCFResonanceCtrl.fvalue = itEvent->Param.CC.Value;                  crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(MIDIKeyVelocity)];
167      }                  break;
168                case ::gig::attenuation_ctrl_t::type_controlchange: //FIXME: currently not sample accurate
169      /**                  crossfadeVolume = Engine::CrossfadeCurve[CrossfadeAttenuation(GetGigEngineChannel()->ControllerTable[pRegion->AttenuationController.controller_number])];
170       *  Synthesizes the current audio fragment for this voice.                  break;
171       *              case ::gig::attenuation_ctrl_t::type_none: // no crossfade defined
172       *  @param Samples - number of sample points to be rendered in this audio              default:
173       *                   fragment cycle                  crossfadeVolume = 1.0f;
      *  @param pSrc    - pointer to input sample data  
      *  @param Skip    - number of sample points to skip in output buffer  
      */  
     void Voice::Synthesize(uint Samples, sample_t* pSrc, uint Skip) {  
         finalSynthesisParameters.pOutLeft  = &pEngineChannel->pChannelLeft->Buffer()[Skip];  
         finalSynthesisParameters.pOutRight = &pEngineChannel->pChannelRight->Buffer()[Skip];  
         finalSynthesisParameters.pSrc      = pSrc;  
   
         RTList<Event>::Iterator itCCEvent = pEngineChannel->pEvents->first();  
         RTList<Event>::Iterator itNoteEvent = pEngineChannel->pMIDIKeyInfo[MIDIKey].pEvents->first();  
   
         if (itTriggerEvent) { // skip events that happened before this voice was triggered  
             while (itCCEvent && itCCEvent->FragmentPos() <= Skip) ++itCCEvent;  
             // we can't simply compare the timestamp here, because note events  
             // might happen on the same time stamp, so we have to deal on the  
             // actual sequence the note events arrived instead (see bug #112)  
             for (; itNoteEvent; ++itNoteEvent) {  
                 if (itTriggerEvent == itNoteEvent) {  
                     ++itNoteEvent;  
                     break;  
                 }  
             }  
174          }          }
175    
176          uint killPos;          return crossfadeVolume;
177          if (itKillEvent) {      }
178              int maxFadeOutPos = Samples - pEngine->MinFadeOutSamples;  
179              if (maxFadeOutPos < 0) {      double Voice::GetEG1ControllerValue(uint8_t MIDIKeyVelocity) {
180                  // There's not enough space in buffer to do a fade out          double eg1controllervalue = 0;
181                  // from max volume (this can only happen for audio          switch (pRegion->EG1Controller.type) {
182                  // drivers that use Samples < MaxSamplesPerCycle).              case ::gig::eg1_ctrl_t::type_none: // no controller defined
183                  // End the EG1 here, at pos 0, with a shorter max fade                  eg1controllervalue = 0;
184                  // out time.                  break;
185                  EG1.enterFadeOutStage(Samples / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);              case ::gig::eg1_ctrl_t::type_channelaftertouch:
186                  itKillEvent = Pool<Event>::Iterator();                  eg1controllervalue = GetGigEngineChannel()->ControllerTable[128];
187              } else {                  break;
188                  killPos = RTMath::Min(itKillEvent->FragmentPos(), maxFadeOutPos);              case ::gig::eg1_ctrl_t::type_velocity:
189              }                  eg1controllervalue = MIDIKeyVelocity;
190                    break;
191                case ::gig::eg1_ctrl_t::type_controlchange: // MIDI control change controller
192                    eg1controllervalue = GetGigEngineChannel()->ControllerTable[pRegion->EG1Controller.controller_number];
193                    break;
194          }          }
195            if (pRegion->EG1ControllerInvert) eg1controllervalue = 127 - eg1controllervalue;
196    
197          uint i = Skip;          return eg1controllervalue;
198          while (i < Samples) {      }
             int iSubFragmentEnd = RTMath::Min(i + CONFIG_DEFAULT_SUBFRAGMENT_SIZE, Samples);  
   
             // initialize all final synthesis parameters  
             fFinalCutoff    = VCFCutoffCtrl.fvalue;  
             fFinalResonance = VCFResonanceCtrl.fvalue;  
   
             // process MIDI control change and pitchbend events for this subfragment  
             processCCEvents(itCCEvent, iSubFragmentEnd);  
   
             finalSynthesisParameters.fFinalPitch = PitchBase * PitchBend;  
             float fFinalVolume = VolumeSmoother.render() * CrossfadeSmoother.render();  
 #ifdef CONFIG_PROCESS_MUTED_CHANNELS  
             if (pEngineChannel->GetMute()) fFinalVolume = 0;  
 #endif  
   
             // process transition events (note on, note off & sustain pedal)  
             processTransitionEvents(itNoteEvent, iSubFragmentEnd);  
   
             // if the voice was killed in this subfragment, or if the  
             // filter EG is finished, switch EG1 to fade out stage  
             if ((itKillEvent && killPos <= iSubFragmentEnd) ||  
                 (SYNTHESIS_MODE_GET_FILTER(SynthesisMode) &&  
                  EG2.getSegmentType() == EGADSR::segment_end)) {  
                 EG1.enterFadeOutStage();  
                 itKillEvent = Pool<Event>::Iterator();  
             }  
199    
200              // process envelope generators      Voice::EGInfo Voice::CalculateEG1ControllerInfluence(double eg1ControllerValue) {
201              switch (EG1.getSegmentType()) {          EGInfo eg;
202                  case EGADSR::segment_lin:          // (eg1attack is different from the others)
203                      fFinalVolume *= EG1.processLin();          if (pRegion->EG1Attack < 1e-8 && // attack in gig == 0
204                      break;              (pRegion->EG1ControllerAttackInfluence == 0 ||
205                  case EGADSR::segment_exp:               eg1ControllerValue <= 10)) { // strange GSt special case
206                      fFinalVolume *= EG1.processExp();              eg.Attack = 0; // this will force the attack to be 0 in the call to EG1.trigger
207                      break;          } else {
208                  case EGADSR::segment_end:              eg.Attack  = (pRegion->EG1ControllerAttackInfluence)  ?
209                      fFinalVolume *= EG1.getLevel();                  1 + 0.031 * (double) (pRegion->EG1ControllerAttackInfluence == 1 ?
210                      break; // noop                                        1 : 1 << pRegion->EG1ControllerAttackInfluence) * eg1ControllerValue : 1.0;
211              }          }
212              switch (EG2.getSegmentType()) {          eg.Decay   = (pRegion->EG1ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pRegion->EG1ControllerDecayInfluence)   * eg1ControllerValue : 1.0;
213                  case EGADSR::segment_lin:          eg.Release = (pRegion->EG1ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pRegion->EG1ControllerReleaseInfluence) * eg1ControllerValue : 1.0;
214                      fFinalCutoff *= EG2.processLin();  
215                      break;          return eg;
216                  case EGADSR::segment_exp:      }
217                      fFinalCutoff *= EG2.processExp();  
218                      break;      double Voice::GetEG2ControllerValue(uint8_t MIDIKeyVelocity) {
219                  case EGADSR::segment_end:          double eg2controllervalue = 0;
220                      fFinalCutoff *= EG2.getLevel();          switch (pRegion->EG2Controller.type) {
221                      break; // noop              case ::gig::eg2_ctrl_t::type_none: // no controller defined
222              }                  eg2controllervalue = 0;
223              if (EG3.active()) finalSynthesisParameters.fFinalPitch *= EG3.render();                  break;
224                case ::gig::eg2_ctrl_t::type_channelaftertouch:
225                    eg2controllervalue = GetGigEngineChannel()->ControllerTable[128];
226                    break;
227                case ::gig::eg2_ctrl_t::type_velocity:
228                    eg2controllervalue = MIDIKeyVelocity;
229                    break;
230                case ::gig::eg2_ctrl_t::type_controlchange: // MIDI control change controller
231                    eg2controllervalue = GetGigEngineChannel()->ControllerTable[pRegion->EG2Controller.controller_number];
232                    break;
233            }
234            if (pRegion->EG2ControllerInvert) eg2controllervalue = 127 - eg2controllervalue;
235    
236              // process low frequency oscillators          return eg2controllervalue;
237              if (bLFO1Enabled) fFinalVolume *= (1.0f - pLFO1->render());      }
             if (bLFO2Enabled) fFinalCutoff *= pLFO2->render();  
             if (bLFO3Enabled) finalSynthesisParameters.fFinalPitch *= RTMath::CentsToFreqRatio(pLFO3->render());  
   
             // limit the pitch so we don't read outside the buffer  
             finalSynthesisParameters.fFinalPitch = RTMath::Min(finalSynthesisParameters.fFinalPitch, float(1 << CONFIG_MAX_PITCH));  
   
             // if filter enabled then update filter coefficients  
             if (SYNTHESIS_MODE_GET_FILTER(SynthesisMode)) {  
                 finalSynthesisParameters.filterLeft.SetParameters(fFinalCutoff, fFinalResonance, pEngine->SampleRate);  
                 finalSynthesisParameters.filterRight.SetParameters(fFinalCutoff, fFinalResonance, pEngine->SampleRate);  
             }  
238    
239              // do we need resampling?      Voice::EGInfo Voice::CalculateEG2ControllerInfluence(double eg2ControllerValue) {
240              const float __PLUS_ONE_CENT  = 1.000577789506554859250142541782224725466f;          EGInfo eg;
241              const float __MINUS_ONE_CENT = 0.9994225441413807496009516495583113737666f;          eg.Attack  = (pRegion->EG2ControllerAttackInfluence)  ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerAttackInfluence)  * eg2ControllerValue : 1.0;
242              const bool bResamplingRequired = !(finalSynthesisParameters.fFinalPitch <= __PLUS_ONE_CENT &&          eg.Decay   = (pRegion->EG2ControllerDecayInfluence)   ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerDecayInfluence)   * eg2ControllerValue : 1.0;
243                                                 finalSynthesisParameters.fFinalPitch >= __MINUS_ONE_CENT);          eg.Release = (pRegion->EG2ControllerReleaseInfluence) ? 1 + 0.00775 * (double) (1 << pRegion->EG2ControllerReleaseInfluence) * eg2ControllerValue : 1.0;
             SYNTHESIS_MODE_SET_INTERPOLATE(SynthesisMode, bResamplingRequired);  
   
             // prepare final synthesis parameters structure  
             finalSynthesisParameters.uiToGo            = iSubFragmentEnd - i;  
 #ifdef CONFIG_INTERPOLATE_VOLUME  
             finalSynthesisParameters.fFinalVolumeDeltaLeft  =  
                 (fFinalVolume * VolumeLeft  * PanLeftSmoother.render() -  
                  finalSynthesisParameters.fFinalVolumeLeft) / finalSynthesisParameters.uiToGo;  
             finalSynthesisParameters.fFinalVolumeDeltaRight =  
                 (fFinalVolume * VolumeRight * PanRightSmoother.render() -  
                  finalSynthesisParameters.fFinalVolumeRight) / finalSynthesisParameters.uiToGo;  
 #else  
             finalSynthesisParameters.fFinalVolumeLeft  =  
                 fFinalVolume * VolumeLeft  * PanLeftSmoother.render();  
             finalSynthesisParameters.fFinalVolumeRight =  
                 fFinalVolume * VolumeRight * PanRightSmoother.render();  
 #endif  
             // render audio for one subfragment  
             RunSynthesisFunction(SynthesisMode, &finalSynthesisParameters, &loop);  
   
             // stop the rendering if volume EG is finished  
             if (EG1.getSegmentType() == EGADSR::segment_end) break;  
   
             const double newPos = Pos + (iSubFragmentEnd - i) * finalSynthesisParameters.fFinalPitch;  
   
             // increment envelopes' positions  
             if (EG1.active()) {  
   
                 // if sample has a loop and loop start has been reached in this subfragment, send a special event to EG1 to let it finish the attack hold stage  
                 if (pDimRgn->SampleLoops && Pos <= pDimRgn->pSampleLoops[0].LoopStart && pDimRgn->pSampleLoops[0].LoopStart < newPos) {  
                     EG1.update(EGADSR::event_hold_end, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);  
                 }  
244    
245                  EG1.increment(1);          return eg;
246                  if (!EG1.toStageEndLeft()) EG1.update(EGADSR::event_stage_end, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);      }
247              }  
248              if (EG2.active()) {      void Voice::InitLFO1() {
249                  EG2.increment(1);          uint16_t lfo1_internal_depth;
250                  if (!EG2.toStageEndLeft()) EG2.update(EGADSR::event_stage_end, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);          switch (pRegion->LFO1Controller) {
251              }              case ::gig::lfo1_ctrl_internal:
252              EG3.increment(1);                  lfo1_internal_depth  = pRegion->LFO1InternalDepth;
253              if (!EG3.toEndLeft()) EG3.update(); // neutralize envelope coefficient if end reached                  pLFO1->ExtController = 0; // no external controller
254                    bLFO1Enabled         = (lfo1_internal_depth > 0);
255                    break;
256                case ::gig::lfo1_ctrl_modwheel:
257                    lfo1_internal_depth  = 0;
258                    pLFO1->ExtController = 1; // MIDI controller 1
259                    bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);
260                    break;
261                case ::gig::lfo1_ctrl_breath:
262                    lfo1_internal_depth  = 0;
263                    pLFO1->ExtController = 2; // MIDI controller 2
264                    bLFO1Enabled         = (pRegion->LFO1ControlDepth > 0);
265                    break;
266                case ::gig::lfo1_ctrl_internal_modwheel:
267                    lfo1_internal_depth  = pRegion->LFO1InternalDepth;
268                    pLFO1->ExtController = 1; // MIDI controller 1
269                    bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);
270                    break;
271                case ::gig::lfo1_ctrl_internal_breath:
272                    lfo1_internal_depth  = pRegion->LFO1InternalDepth;
273                    pLFO1->ExtController = 2; // MIDI controller 2
274                    bLFO1Enabled         = (lfo1_internal_depth > 0 || pRegion->LFO1ControlDepth > 0);
275                    break;
276                default:
277                    lfo1_internal_depth  = 0;
278                    pLFO1->ExtController = 0; // no external controller
279                    bLFO1Enabled         = false;
280            }
281            if (bLFO1Enabled) {
282                pLFO1->trigger(fromGigLfoWave(pRegion->LFO1WaveForm),
283                               pRegion->LFO1Frequency,
284                               pRegion->LFO1Phase,
285                               LFO::start_level_mid, // see https://sourceforge.net/p/linuxsampler/mailman/linuxsampler-devel/thread/2189307.cNP0Xbctxq%40silver/#msg36774029
286                               lfo1_internal_depth,
287                               pRegion->LFO1ControlDepth,
288                               pRegion->LFO1FlipPhase,
289                               pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
290                pLFO1->updateByMIDICtrlValue(pLFO1->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO1->ExtController] : 0);
291                pLFO1->setScriptDepthFactor(
292                    pNote->Override.AmpLFODepth.Value,
293                    pNote->Override.AmpLFODepth.Final
294                );
295                if (pNote->Override.AmpLFOFreq.isFinal())
296                    pLFO1->setScriptFrequencyFinal(
297                        pNote->Override.AmpLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE
298                    );
299                else
300                    pLFO1->setScriptFrequencyFactor(
301                        pNote->Override.AmpLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE
302                    );
303            }
304        }
305    
306        void Voice::InitLFO2() {
307            uint16_t lfo2_internal_depth;
308            switch (pRegion->LFO2Controller) {
309                case ::gig::lfo2_ctrl_internal:
310                    lfo2_internal_depth  = pRegion->LFO2InternalDepth;
311                    pLFO2->ExtController = 0; // no external controller
312                    bLFO2Enabled         = (lfo2_internal_depth > 0);
313                    break;
314                case ::gig::lfo2_ctrl_modwheel:
315                    lfo2_internal_depth  = 0;
316                    pLFO2->ExtController = 1; // MIDI controller 1
317                    bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);
318                    break;
319                case ::gig::lfo2_ctrl_foot:
320                    lfo2_internal_depth  = 0;
321                    pLFO2->ExtController = 4; // MIDI controller 4
322                    bLFO2Enabled         = (pRegion->LFO2ControlDepth > 0);
323                    break;
324                case ::gig::lfo2_ctrl_internal_modwheel:
325                    lfo2_internal_depth  = pRegion->LFO2InternalDepth;
326                    pLFO2->ExtController = 1; // MIDI controller 1
327                    bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);
328                    break;
329                case ::gig::lfo2_ctrl_internal_foot:
330                    lfo2_internal_depth  = pRegion->LFO2InternalDepth;
331                    pLFO2->ExtController = 4; // MIDI controller 4
332                    bLFO2Enabled         = (lfo2_internal_depth > 0 || pRegion->LFO2ControlDepth > 0);
333                    break;
334                default:
335                    lfo2_internal_depth  = 0;
336                    pLFO2->ExtController = 0; // no external controller
337                    bLFO2Enabled         = false;
338            }
339            if (bLFO2Enabled) {
340                pLFO2->trigger(fromGigLfoWave(pRegion->LFO2WaveForm),
341                               pRegion->LFO2Frequency,
342                               pRegion->LFO2Phase,
343                               LFO::start_level_mid, // see https://sourceforge.net/p/linuxsampler/mailman/linuxsampler-devel/thread/2189307.cNP0Xbctxq%40silver/#msg36774029
344                               lfo2_internal_depth,
345                               pRegion->LFO2ControlDepth,
346                               pRegion->LFO2FlipPhase,
347                               pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
348                pLFO2->updateByMIDICtrlValue(pLFO2->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO2->ExtController] : 0);
349                pLFO2->setScriptDepthFactor(
350                    pNote->Override.CutoffLFODepth.Value,
351                    pNote->Override.CutoffLFODepth.Final
352                );
353                if (pNote->Override.CutoffLFOFreq.isFinal())
354                    pLFO2->setScriptFrequencyFinal(pNote->Override.CutoffLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
355                else
356                    pLFO2->setScriptFrequencyFactor(pNote->Override.CutoffLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
357            }
358        }
359    
360        void Voice::InitLFO3() {
361            uint16_t lfo3_internal_depth;
362            switch (pRegion->LFO3Controller) {
363                case ::gig::lfo3_ctrl_internal:
364                    lfo3_internal_depth  = pRegion->LFO3InternalDepth;
365                    pLFO3->ExtController = 0; // no external controller
366                    bLFO3Enabled         = (lfo3_internal_depth > 0);
367                    break;
368                case ::gig::lfo3_ctrl_modwheel:
369                    lfo3_internal_depth  = 0;
370                    pLFO3->ExtController = 1; // MIDI controller 1
371                    bLFO3Enabled         = (pRegion->LFO3ControlDepth > 0);
372                    break;
373                case ::gig::lfo3_ctrl_aftertouch:
374                    lfo3_internal_depth  = 0;
375                    pLFO3->ExtController = CTRL_TABLE_IDX_AFTERTOUCH;
376                    bLFO3Enabled         = true;
377                    break;
378                case ::gig::lfo3_ctrl_internal_modwheel:
379                    lfo3_internal_depth  = pRegion->LFO3InternalDepth;
380                    pLFO3->ExtController = 1; // MIDI controller 1
381                    bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);
382                    break;
383                case ::gig::lfo3_ctrl_internal_aftertouch:
384                    lfo3_internal_depth  = pRegion->LFO3InternalDepth;
385                    pLFO3->ExtController = CTRL_TABLE_IDX_AFTERTOUCH;
386                    bLFO3Enabled         = (lfo3_internal_depth > 0 || pRegion->LFO3ControlDepth > 0);
387                    break;
388                default:
389                    lfo3_internal_depth  = 0;
390                    pLFO3->ExtController = 0; // no external controller
391                    bLFO3Enabled         = false;
392            }
393            if (bLFO3Enabled) {
394                pLFO3->trigger(fromGigLfoWave(pRegion->LFO3WaveForm),
395                               pRegion->LFO3Frequency,
396                               pRegion->LFO3Phase,
397                               LFO::start_level_max, // see https://sourceforge.net/p/linuxsampler/mailman/linuxsampler-devel/thread/2189307.cNP0Xbctxq%40silver/#msg36774029
398                               lfo3_internal_depth,
399                               pRegion->LFO3ControlDepth,
400                               pRegion->LFO3FlipPhase,
401                               pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
402                pLFO3->updateByMIDICtrlValue(pLFO3->ExtController ? GetGigEngineChannel()->ControllerTable[pLFO3->ExtController] : 0);
403                pLFO3->setScriptDepthFactor(
404                    pNote->Override.PitchLFODepth.Value,
405                    pNote->Override.PitchLFODepth.Final
406                );
407                if (pNote->Override.PitchLFOFreq.isFinal())
408                    pLFO3->setScriptFrequencyFinal(pNote->Override.PitchLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
409                else
410                    pLFO3->setScriptFrequencyFactor(pNote->Override.PitchLFOFreq.Value, pEngine->SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
411            }
412        }
413    
414              Pos = newPos;      float Voice::CalculateCutoffBase(uint8_t MIDIKeyVelocity) {
415              i = iSubFragmentEnd;          float cutoff = pRegion->GetVelocityCutoff(MIDIKeyVelocity);
416            if (pRegion->VCFKeyboardTracking) {
417                cutoff *= RTMath::CentsToFreqRatioUnlimited((MIDIKey() - pRegion->VCFKeyboardTrackingBreakpoint) * 100);
418            }
419            return cutoff;
420        }
421    
422        float Voice::CalculateFinalCutoff(float cutoffBase) {
423            int cvalue;
424            if (VCFCutoffCtrl.controller) {
425                cvalue = GetGigEngineChannel()->ControllerTable[VCFCutoffCtrl.controller];
426                if (pRegion->VCFCutoffControllerInvert) cvalue = 127 - cvalue;
427                // VCFVelocityScale in this case means Minimum cutoff
428                if (cvalue < pRegion->VCFVelocityScale) cvalue = pRegion->VCFVelocityScale;
429          }          }
430            else {
431                cvalue = pRegion->VCFCutoff;
432            }
433            float fco = cutoffBase * float(cvalue);
434            if (fco > 127.0f) fco = 127.0f;
435    
436            return fco;
437      }      }
438    
439      /** @brief Update current portamento position.      uint8_t Voice::GetVCFCutoffCtrl() {
440       *          uint8_t ctrl;
441       * Will be called when portamento mode is enabled to get the final          switch (pRegion->VCFCutoffController) {
442       * portamento position of this active voice from where the next voice(s)              case ::gig::vcf_cutoff_ctrl_modwheel:
443       * might continue to slide on.                  ctrl = 1;
444       *                  break;
445       * @param itNoteOffEvent - event which causes this voice to die soon              case ::gig::vcf_cutoff_ctrl_effect1:
446       */                  ctrl = 12;
447      void Voice::UpdatePortamentoPos(Pool<Event>::Iterator& itNoteOffEvent) {                  break;
448          const float fFinalEG3Level = EG3.level(itNoteOffEvent->FragmentPos());              case ::gig::vcf_cutoff_ctrl_effect2:
449          pEngineChannel->PortamentoPos = (float) MIDIKey + RTMath::FreqRatioToCents(fFinalEG3Level) * 0.01f;                  ctrl = 13;
450      }                  break;
451                case ::gig::vcf_cutoff_ctrl_breath:
452      /**                  ctrl = 2;
453       *  Immediately kill the voice. This method should not be used to kill                  break;
454       *  a normal, active voice, because it doesn't take care of things like              case ::gig::vcf_cutoff_ctrl_foot:
455       *  fading down the volume level to avoid clicks and regular processing                  ctrl = 4;
456       *  until the kill event actually occured!                  break;
457       *              case ::gig::vcf_cutoff_ctrl_sustainpedal:
458       * If it's necessary to know when the voice's disk stream was actually                  ctrl = 64;
459       * deleted, then one can set the optional @a bRequestNotification                  break;
460       * parameter and this method will then return the handle of the disk              case ::gig::vcf_cutoff_ctrl_softpedal:
461       * stream (unique identifier) and one can use this handle to poll the                  ctrl = 67;
462       * disk thread if this stream has been deleted. In any case this method                  break;
463       * will return immediately and will not block until the stream actually              case ::gig::vcf_cutoff_ctrl_genpurpose7:
464       * was deleted.                  ctrl = 82;
465       *                  break;
466       * @param bRequestNotification - (optional) whether the disk thread shall              case ::gig::vcf_cutoff_ctrl_genpurpose8:
467       *                                provide a notification once it deleted                  ctrl = 83;
468       *                               the respective disk stream                  break;
469       *                               (default=false)              case ::gig::vcf_cutoff_ctrl_aftertouch:
470       * @returns handle to the voice's disk stream or @c Stream::INVALID_HANDLE                  ctrl = CTRL_TABLE_IDX_AFTERTOUCH;
471       *          if the voice did not use a disk stream at all                  break;
472       * @see Kill()              case ::gig::vcf_cutoff_ctrl_none:
473       */              default:
474      Stream::Handle Voice::KillImmediately(bool bRequestNotification) {                  ctrl = 0;
475          Stream::Handle hStream = Stream::INVALID_HANDLE;                  break;
476          if (DiskVoice && DiskStreamRef.State != Stream::state_unused) {          }
             pDiskThread->OrderDeletionOfStream(&DiskStreamRef, bRequestNotification);  
             hStream = DiskStreamRef.hStream;  
         }  
         Reset();  
         return hStream;  
     }  
   
     /**  
      *  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 itKillEvent - event which caused the voice to be killed  
      */  
     void Voice::Kill(Pool<Event>::Iterator& itKillEvent) {  
         #if CONFIG_DEVMODE  
         if (!itKillEvent) dmsg(1,("gig::Voice::Kill(): ERROR, !itKillEvent !!!\n"));  
         if (itKillEvent && !itKillEvent.isValid()) dmsg(1,("gig::Voice::Kill(): ERROR, itKillEvent invalid !!!\n"));  
         #endif // CONFIG_DEVMODE  
477    
478          if (itTriggerEvent && itKillEvent->FragmentPos() <= itTriggerEvent->FragmentPos()) return;          return ctrl;
479          this->itKillEvent = itKillEvent;      }
480    
481        uint8_t Voice::GetVCFResonanceCtrl() {
482            uint8_t ctrl;
483            switch (pRegion->VCFResonanceController) {
484                case ::gig::vcf_res_ctrl_genpurpose3:
485                    ctrl = 18;
486                    break;
487                case ::gig::vcf_res_ctrl_genpurpose4:
488                    ctrl = 19;
489                    break;
490                case ::gig::vcf_res_ctrl_genpurpose5:
491                    ctrl = 80;
492                    break;
493                case ::gig::vcf_res_ctrl_genpurpose6:
494                    ctrl = 81;
495                    break;
496                case ::gig::vcf_res_ctrl_none:
497                default:
498                    ctrl = 0;
499            }
500    
501            return ctrl;
502        }
503    
504        void Voice::TriggerEG1(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) {
505            EG1.setStateOptions(
506                pRegion->EG1Options.AttackCancel,
507                pRegion->EG1Options.AttackHoldCancel,
508                pRegion->EG1Options.Decay1Cancel,
509                pRegion->EG1Options.Decay2Cancel,
510                pRegion->EG1Options.ReleaseCancel
511            );
512            EG1.trigger(pRegion->EG1PreAttack,
513                        (pNote && pNote->Override.Attack.isFinal()) ?
514                            pNote->Override.Attack.Value :
515                            RTMath::Max(pRegion->EG1Attack, 0.0316) * egInfo.Attack,
516                        pRegion->EG1Hold,
517                        (pNote && pNote->Override.Decay.isFinal()) ?
518                            pNote->Override.Decay.Value :
519                            pRegion->EG1Decay1 * egInfo.Decay * velrelease,
520                        (pNote && pNote->Override.Decay.isFinal()) ?
521                            pNote->Override.Decay.Value :
522                            pRegion->EG1Decay2 * egInfo.Decay * velrelease,
523                        pRegion->EG1InfiniteSustain,
524                        (pNote && pNote->Override.Sustain.Final) ?
525                            uint(pNote->Override.Sustain.Value * 1000.f) :
526                            pRegion->EG1Sustain * (pNote ? pNote->Override.Sustain.Value : 1.f),
527                        (pNote && pNote->Override.Release.isFinal()) ?
528                            pNote->Override.Release.Value :
529                            RTMath::Max(pRegion->EG1Release * velrelease, 0.014) * egInfo.Release,
530                        velocityAttenuation,
531                        sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
532        }
533    
534        void Voice::TriggerEG2(const EGInfo& egInfo, double velrelease, double velocityAttenuation, uint sampleRate, uint8_t velocity) {
535            EG2.setStateOptions(
536                pRegion->EG2Options.AttackCancel,
537                pRegion->EG2Options.AttackHoldCancel,
538                pRegion->EG2Options.Decay1Cancel,
539                pRegion->EG2Options.Decay2Cancel,
540                pRegion->EG2Options.ReleaseCancel
541            );
542            EG2.trigger(uint(RgnInfo.EG2PreAttack),
543                        (pNote && pNote->Override.CutoffAttack.isFinal()) ?
544                            pNote->Override.CutoffAttack.Value :
545                            RgnInfo.EG2Attack * egInfo.Attack,
546                        false,
547                        (pNote && pNote->Override.CutoffDecay.isFinal()) ?
548                            pNote->Override.CutoffDecay.Value :
549                            RgnInfo.EG2Decay1 * egInfo.Decay * velrelease,
550                        (pNote && pNote->Override.CutoffDecay.isFinal()) ?
551                            pNote->Override.CutoffDecay.Value :
552                            RgnInfo.EG2Decay2 * egInfo.Decay * velrelease,
553                        RgnInfo.EG2InfiniteSustain,
554                        (pNote && pNote->Override.CutoffSustain.Final) ?
555                            uint(pNote->Override.CutoffSustain.Value * 1000.f) :
556                            uint(RgnInfo.EG2Sustain),
557                        (pNote && pNote->Override.CutoffRelease.isFinal()) ?
558                            pNote->Override.CutoffRelease.Value :
559                            RgnInfo.EG2Release * egInfo.Release * velrelease,
560                        velocityAttenuation,
561                        sampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE);
562        }
563    
564        void Voice::ProcessGroupEvent(RTList<Event>::Iterator& itEvent) {
565            dmsg(4,("Voice %p processGroupEvents event type=%d", (void*)this, itEvent->Type));
566    
567            // TODO: The SustainPedal condition could be wrong, maybe the
568            // check should be if this Voice is in release stage or is a
569            // release sample instead. Need to test this in GSt.
570            // -- Andreas
571            //
572            // Commented sustain pedal check out. I don't think voices of the same
573            // note should be stopped at all, because it doesn't sound naturally
574            // with a drumkit.
575            // -- Christian, 2013-01-08
576            if (itEvent->Param.Note.Key != HostKey() /*||
577                !GetGigEngineChannel()->SustainPedal*/) {
578                dmsg(4,("Voice %p - kill", (void*)this));
579    
580                // kill the voice fast
581                pEG1->enterFadeOutStage();
582            }
583        }
584    
585        void Voice::CalculateFadeOutCoeff(float FadeOutTime, float SampleRate) {
586            EG1.CalculateFadeOutCoeff(FadeOutTime, SampleRate);
587        }
588    
589        int Voice::CalculatePan(uint8_t pan) {
590            int p;
591            // Gst behaviour: -64 and 63 are special cases
592            if (RgnInfo.Pan == -64)     p = pan * 2 - 127;
593            else if (RgnInfo.Pan == 63) p = pan * 2;
594            else                        p = pan + RgnInfo.Pan;
595    
596            if (p < 0) return 0;
597            if (p > 127) return 127;
598            return p;
599        }
600    
601        release_trigger_t Voice::GetReleaseTriggerFlags() {
602            release_trigger_t flags =
603                (pRegion->NoNoteOffReleaseTrigger) ?
604                    release_trigger_none : release_trigger_noteoff; //HACK: currently this method is actually only called by EngineBase if it already knows that this voice requires release trigger, so I took the short way instead of checking (again) the existence of a ::gig::dimension_releasetrigger
605            switch (pRegion->SustainReleaseTrigger) {
606                case ::gig::sust_rel_trg_none:
607                    break;
608                case ::gig::sust_rel_trg_maxvelocity:
609                    flags |= release_trigger_sustain_maxvelocity;
610                    break;
611                case ::gig::sust_rel_trg_keyvelocity:
612                    flags |= release_trigger_sustain_keyvelocity;
613                    break;
614            }
615            return flags;
616      }      }
617    
618  }} // namespace LinuxSampler::gig  }} // namespace LinuxSampler::gig
Legend:
Removed from v.1923  
changed lines
  Added in v.3625
  ViewVC Help
Powered by ViewVC