--- linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.cpp	2011/07/28 08:05:57	2218
+++ linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.cpp	2011/08/10 19:40:39	2235
@@ -22,6 +22,7 @@
 
 #include "SfzSignalUnitRack.h"
 #include "Voice.h"
+#include <SF.h>
 
 namespace LinuxSampler { namespace sfz {
     
@@ -33,25 +34,282 @@
         return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
     }
     
+    float SfzSignalUnit::GetInfluence(ArrayList< ::sfz::CC>& cc) {
+        float f = 0;
+        for (int i = 0; i < cc.size(); i++) {
+            int val = pVoice->GetControllerValue(cc[i].Controller);
+            f += (val / 127.0f) * cc[i].Influence;
+        }
+        return f;
+    }
+    
     
-    void EGv1Unit::Trigger() {
+    EGv2Unit::EGv2Unit(SfzSignalUnitRack* rack)
+        : EGUnit< ::LinuxSampler::sfz::EG>(rack),
+          suAmpOnCC(rack), suVolOnCC(rack), suPitchOnCC(rack), suCutoffOnCC(rack), suResOnCC(rack)
+    { }
+    
+    void EGv2Unit::Trigger() {
+        egInfo = *pEGInfo;
+        for (int i = 0; i < egInfo.node.size(); i++) {
+            float f = GetInfluence(egInfo.node[i].level_oncc);
+            egInfo.node[i].level = std::min(egInfo.node[i].level + f, 1.0f);
+            
+            f = GetInfluence(egInfo.node[i].time_oncc);
+            egInfo.node[i].time = std::min(egInfo.node[i].time + f, 100.0f);
+        }
+        EG.trigger(egInfo, GetSampleRate(), pVoice->MIDIVelocity);
+    }
+    
+    
+    void PitchEGUnit::Trigger() {
         ::sfz::Region* const pRegion = pVoice->pRegion;
+        depth = pRegion->pitcheg_depth;
+        
         // the length of the decay and release curves are dependent on the velocity
         const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
 
-        EG.trigger(uint(pRegion->ampeg_start * 10),
-                   std::max(0.0, pRegion->ampeg_attack + pRegion->ampeg_vel2attack * velrelease),
-                   std::max(0.0, pRegion->ampeg_hold + pRegion->ampeg_vel2hold * velrelease),
-                   std::max(0.0, pRegion->ampeg_decay + pRegion->ampeg_vel2decay * velrelease),
-                   uint(std::min(std::max(0.0, 10 * (pRegion->ampeg_sustain + pRegion->ampeg_vel2sustain * velrelease)), 1000.0)),
-                   std::max(0.0, pRegion->ampeg_release + pRegion->ampeg_vel2release * velrelease),
+        // set the delay trigger
+        uiDelayTrigger = (pRegion->pitcheg_delay + pRegion->pitcheg_vel2delay * velrelease) * GetSampleRate();
+        
+        EG.trigger(uint(pRegion->pitcheg_start * 10),
+                   std::max(0.0, pRegion->pitcheg_attack + pRegion->pitcheg_vel2attack * velrelease),
+                   std::max(0.0, pRegion->pitcheg_hold + pRegion->pitcheg_vel2hold * velrelease),
+                   std::max(0.0, pRegion->pitcheg_decay + pRegion->pitcheg_vel2decay * velrelease),
+                   uint(std::min(std::max(0.0, 10 * (pRegion->pitcheg_sustain + pRegion->pitcheg_vel2sustain * velrelease)), 1000.0)),
+                   std::max(0.0, pRegion->pitcheg_release + pRegion->pitcheg_vel2release * velrelease),
                    GetSampleRate());
     }
     
-    void EGv2Unit::Trigger() {
-        EG.trigger(*pEGInfo, GetSampleRate(), pVoice->MIDIVelocity);
+    
+    void FilEGUnit::Trigger() {
+        ::sfz::Region* const pRegion = pVoice->pRegion;
+        depth = pRegion->fileg_depth;
+        
+        // the length of the decay and release curves are dependent on the velocity
+        const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
+
+        // set the delay trigger
+        uiDelayTrigger = (pRegion->fileg_delay + pRegion->fileg_vel2delay * velrelease) * GetSampleRate();
+        
+        EG.trigger(uint(pRegion->fileg_start * 10),
+                   std::max(0.0, pRegion->fileg_attack + pRegion->fileg_vel2attack * velrelease),
+                   std::max(0.0, pRegion->fileg_hold + pRegion->fileg_vel2hold * velrelease),
+                   std::max(0.0, pRegion->fileg_decay + pRegion->fileg_vel2decay * velrelease),
+                   uint(std::min(std::max(0.0, 10 * (pRegion->fileg_sustain + pRegion->fileg_vel2sustain * velrelease)), 1000.0)),
+                   std::max(0.0, pRegion->fileg_release + pRegion->fileg_vel2release * velrelease),
+                   GetSampleRate());
+    }
+    
+    
+    void AmpEGUnit::Trigger() {
+        ::sfz::Region* const pRegion = pVoice->pRegion;
+        
+        // the length of the decay and release curves are dependent on the velocity
+        const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
+
+        // set the delay trigger
+        float delay = pRegion->ampeg_delay + pRegion->ampeg_vel2delay * velrelease;
+        delay += GetInfluence(pRegion->ampeg_delaycc);
+        uiDelayTrigger = std::max(0.0f, delay) * GetSampleRate();
+        
+        float start = (pRegion->ampeg_start + GetInfluence(pRegion->ampeg_startcc)) * 10;
+        
+        float attack = pRegion->ampeg_attack + pRegion->ampeg_vel2attack * velrelease;
+        attack = std::max(0.0f, attack + GetInfluence(pRegion->ampeg_attackcc));
+        
+        float hold = pRegion->ampeg_hold + pRegion->ampeg_vel2hold * velrelease;
+        hold = std::max(0.0f, hold + GetInfluence(pRegion->ampeg_holdcc));
+        
+        float decay = pRegion->ampeg_decay + pRegion->ampeg_vel2decay * velrelease;
+        decay = std::max(0.0f, decay + GetInfluence(pRegion->ampeg_decaycc));
+        
+        float sustain = pRegion->ampeg_sustain + pRegion->ampeg_vel2sustain * velrelease;
+        sustain = 10 * (sustain + GetInfluence(pRegion->ampeg_sustaincc));
+        
+        float release = pRegion->ampeg_release + pRegion->ampeg_vel2release * velrelease;
+        release = std::max(0.0f, release + GetInfluence(pRegion->ampeg_releasecc));
+        
+        EG.trigger (
+            uint(std::min(std::max(0.0f, start), 1000.0f)), attack, hold, decay,
+            uint(std::min(std::max(0.0f, sustain), 1000.0f)), release, GetSampleRate()
+        );
+    }
+    
+    
+    LFOUnit::LFOUnit(SfzSignalUnitRack* rack)
+        : SfzSignalUnit(rack), pLfoInfo(NULL), pLFO(NULL),
+          suFadeEG(rack), suFreqOnCC(rack, this), suDepthOnCC(rack)
+    { }
+    
+    LFOUnit::LFOUnit(const LFOUnit& Unit)
+        : SfzSignalUnit(Unit), suFadeEG(static_cast<SfzSignalUnitRack*>(Unit.pRack)),
+          suFreqOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack), this),
+          suDepthOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack))
+    {
+        Copy(Unit);
     }
 
+    void LFOUnit::Increment() {
+        if (DelayStage()) return;
+        
+        SignalUnit::Increment();
+        
+        Level = pLFO->Render();
+        if (suFadeEG.Active()) Level *= suFadeEG.GetLevel();
+    }
+    
+    void LFOUnit::Trigger() {
+        //reset
+        Level = 0;
+        
+        // set the delay trigger
+        uiDelayTrigger = (pLfoInfo->delay + GetInfluence(pLfoInfo->delay_oncc)) * GetSampleRate();
+        if(pLfoInfo->fade != 0 || !pLfoInfo->fade_oncc.empty()) {
+            float f = pLfoInfo->fade;
+            f += GetInfluence(pLfoInfo->fade_oncc);
+            
+            if (f != 0) {
+                suFadeEG.uiDelayTrigger = pLfoInfo->delay * GetSampleRate();
+                suFadeEG.EG.trigger(0, f, 0, 0, 1000, 0, GetSampleRate());
+            }
+        }
+    }
+    
+    void LFOUnit::ValueChanged(CCSignalUnit* pUnit) {
+        pLFO->SetFrequency(std::max(0.0f, suFreqOnCC.GetLevel() + pLfoInfo->freq), GetSampleRate());
+    }
+    
+    
+    void LFOv1Unit::Trigger() {
+        LFOUnit::Trigger();
+        
+        lfo.trigger (
+            pLfoInfo->freq + suFreqOnCC.GetLevel(),
+            start_level_mid,
+            1, 0, false, GetSampleRate()
+        );
+        lfo.update(0);
+    }
+    
+    
+    LFOv2Unit::LFOv2Unit(SfzSignalUnitRack* rack)
+        : LFOUnit(rack), lfos(8), lfo0(1200.0f), lfo1(1200.0f), lfo2(1200.0f),
+          lfo3(1200.0f), lfo4(1200.0f), lfo5(1200.0f), lfo6(1200.0f), lfo7(1200.0f),
+          suVolOnCC(rack), suPitchOnCC(rack), suPanOnCC(rack), suCutoffOnCC(rack), suResOnCC(rack)
+    {
+        lfos.add(&lfo0);
+        lfos.add(&lfo1);
+        lfos.add(&lfo2);
+        lfos.add(&lfo3);
+        lfos.add(&lfo4);
+        lfos.add(&lfo5);
+        lfos.add(&lfo6);
+        lfos.add(&lfo7);
+    }
+    
+    void LFOv2Unit::Trigger() {
+        LFOUnit::Trigger();
+        
+        if (pLfoInfo->wave < 0 || pLfoInfo->wave >= lfos.size()) pLFO = &lfo0;
+        else pLFO = lfos[pLfoInfo->wave];
+        
+        pLFO->Trigger (
+            pLfoInfo->freq + suFreqOnCC.GetLevel(),
+            start_level_mid,
+            1, 0, false, GetSampleRate()
+        );
+        pLFO->Update(0);
+        
+        float phase = pLfoInfo->phase + GetInfluence(pLfoInfo->phase_oncc);
+        if (phase != 0) pLFO->SetPhase(phase);
+    }
+    
+    void AmpLFOUnit::Trigger() {
+        ::sfz::Region* const pRegion = pVoice->pRegion;
+        pLfoInfo->delay  = pRegion->amplfo_delay;
+        pLfoInfo->freq   = pRegion->amplfo_freq;
+        pLfoInfo->fade   = pRegion->amplfo_fade;
+        pLfoInfo->volume = pRegion->amplfo_depth;
+        
+        LFOv1Unit::Trigger();
+    }
+    
+    void PitchLFOUnit::Trigger() {
+        ::sfz::Region* const pRegion = pVoice->pRegion;
+        pLfoInfo->delay = pRegion->pitchlfo_delay;
+        pLfoInfo->freq  = pRegion->pitchlfo_freq;
+        pLfoInfo->fade  = pRegion->pitchlfo_fade;
+        pLfoInfo->pitch = pRegion->pitchlfo_depth;
+        
+        LFOv1Unit::Trigger();
+    }
+    
+    void FilLFOUnit::Trigger() {
+        ::sfz::Region* const pRegion = pVoice->pRegion;
+        pLfoInfo->delay  = pRegion->fillfo_delay;
+        pLfoInfo->freq   = pRegion->fillfo_freq;
+        pLfoInfo->fade   = pRegion->fillfo_fade;
+        pLfoInfo->cutoff = pRegion->fillfo_depth;
+        
+        LFOv1Unit::Trigger();
+    }
+    
+    CCUnit::CCUnit(SfzSignalUnitRack* rack, Listener* l): CCSignalUnit(rack, l) {
+        pVoice = NULL;
+    }
+    
+    void CCUnit::Trigger() {
+        for (int i = 0; i < Ctrls.size(); i++) {
+            Ctrls[i].Value = pVoice->GetControllerValue(Ctrls[i].Controller);
+            if (Ctrls[i].pSmoother != NULL) Ctrls[i].pSmoother->setValue(Ctrls[i].Value);
+        }
+        CCSignalUnit::Trigger();
+    }
+    
+     void CCUnit::SetCCs(::sfz::Array<int>& cc) {
+         RemoveAllCCs();
+         for (int i = 0; i < 128; i++) {
+             if (cc[i] != 0) AddCC(i, cc[i]);
+         }
+     }
+    
+     void CCUnit::SetCCs(ArrayList< ::sfz::CC>& cc) {
+         RemoveAllCCs();
+         for (int i = 0; i < cc.size(); i++) {
+             if (cc[i].Influence != 0) {
+                 short int curve = cc[i].Curve;
+                 if (curve >= GetCurveCount()) curve = -1;
+                 AddSmoothCC(cc[i].Controller, cc[i].Influence, curve, cc[i].Smooth);
+             }
+         }
+     }
+     
+     void CCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
+         AddCC(Controller, Influence, Curve);
+     }
+     
+     int CCUnit::GetCurveCount() {
+         return pVoice->pRegion->GetInstrument()->curves.size();
+     }
+     
+     ::sfz::Curve* CCUnit::GetCurve(int idx) { 
+         return &pVoice->pRegion->GetInstrument()->curves[idx];
+     }
+     
+     double CCUnit::GetSampleRate() {
+        return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
+    }
+     
+     void SmoothCCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
+         if (Smooth > 0) {
+             Smoothers[Controller].trigger(Smooth / 1000.0f, GetSampleRate());
+             AddCC(Controller, Influence, Curve, &Smoothers[Controller]);
+         } else {
+             AddCC(Controller, Influence, Curve);
+         }
+     }
+
 
     EndpointUnit::EndpointUnit(SfzSignalUnitRack* rack): EndpointSignalUnit(rack) {
         
@@ -82,63 +340,244 @@
         for (int i = 0; i < GetRack()->volEGs.size(); i++) {
             EGv2Unit* eg = GetRack()->volEGs[i];
             if (!eg->Active()) continue;
-            vol += eg->GetLevel() * (eg->pEGInfo->amplitude / 100.0f);
+            
+            float dB = eg->suVolOnCC.Active() ? eg->suVolOnCC.GetLevel() : -200;
+            if (dB < -144) dB = eg->pEGInfo->volume;
+            else if (eg->pEGInfo->volume >= -144) dB += eg->pEGInfo->volume;
+            
+            float amp = eg->suAmpOnCC.Active() ? eg->suAmpOnCC.GetLevel() : 0;
+            amp = (amp + eg->pEGInfo->amplitude) / 100.0f;
+            
+            if (dB >= -144) {
+                if (amp == 0 && eg->suAmpOnCC.GetCCCount() == 0) amp = 1.0f;
+                amp *= ::sf2::ToRatio(dB * 10.0);
+            }
+            
+            vol += amp * eg->GetLevel();
+        }
+        
+        AmpLFOUnit* u = &(GetRack()->suAmpLFO);
+        CCSignalUnit* u2 = &(GetRack()->suAmpLFO.suDepthOnCC);
+        float f = u2->Active() ? u2->GetLevel() : 0;
+        vol *= u->Active() ? ::sf2::ToRatio((u->GetLevel() * (u->pLfoInfo->volume + f) * 10.0)) : 1;
+        
+        vol *= ::sf2::ToRatio(GetRack()->suVolOnCC.GetLevel() * 10.0);
+        
+        for (int i = 0; i < GetRack()->volLFOs.size(); i++) {
+            LFOv2Unit* lfo = GetRack()->volLFOs[i];
+            if (!lfo->Active()) continue;
+            
+            float f = lfo->suVolOnCC.Active() ? lfo->suVolOnCC.GetLevel() : 0;
+            vol *= ::sf2::ToRatio(lfo->GetLevel() * (lfo->pLfoInfo->volume + f) * 10.0);
         }
         
         return vol;
     }
     
     float EndpointUnit::GetFilterCutoff() {
-        return 1;
+        float val;
+        
+        FilLFOUnit* u = &(GetRack()->suFilLFO);
+        CCSignalUnit* u1 = &(GetRack()->suFilLFO.suDepthOnCC);
+        float f = u1->Active() ? u1->GetLevel() : 0;
+        val = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * (u->pLfoInfo->cutoff + f)) : 1;
+        
+        FilEGUnit* u2 = &(GetRack()->suFilEG);
+        val *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * u2->depth) : 1;
+        
+        for (int i = 0; i < GetRack()->filEGs.size(); i++) {
+            EGv2Unit* eg = GetRack()->filEGs[i];
+            if (!eg->Active()) continue;
+            
+            float f = eg->suCutoffOnCC.Active() ? eg->suCutoffOnCC.GetLevel() : 0;
+            f = eg->GetLevel() * (eg->pEGInfo->cutoff + f);
+            val *= RTMath::CentsToFreqRatioUnlimited(f);
+        }
+        
+        for (int i = 0; i < GetRack()->filLFOs.size(); i++) {
+            LFOv2Unit* lfo = GetRack()->filLFOs[i];
+            if (!lfo->Active()) continue;
+            
+            float f = lfo->suCutoffOnCC.Active() ? lfo->suCutoffOnCC.GetLevel() : 0;
+            f = lfo->GetLevel() * (lfo->pLfoInfo->cutoff + f);
+            val *= RTMath::CentsToFreqRatioUnlimited(f);
+        }
+        
+        return val;
+    }
+    
+    float EndpointUnit::CalculateFilterCutoff(float cutoff) {
+         cutoff *= GetFilterCutoff();
+         float maxCutoff = 0.49 * pVoice->GetSampleRate();
+         return cutoff > maxCutoff ? maxCutoff : cutoff;
     }
     
     float EndpointUnit::GetPitch() {
-        return 1;
+        double p;
+        EGv1Unit* u = &(GetRack()->suPitchEG);
+        p = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->depth) : 1;
+        
+        for (int i = 0; i < GetRack()->pitchEGs.size(); i++) {
+            EGv2Unit* eg = GetRack()->pitchEGs[i];
+            if (!eg->Active()) continue;
+            
+            float f = eg->suPitchOnCC.Active() ? eg->suPitchOnCC.GetLevel() : 0;
+            p *= RTMath::CentsToFreqRatioUnlimited(eg->GetLevel() * (eg->pEGInfo->pitch + f));
+        }
+        
+        PitchLFOUnit* u2 = &(GetRack()->suPitchLFO);
+        CCSignalUnit* u3 = &(GetRack()->suPitchLFO.suDepthOnCC);
+        float f = u3->Active() ? u3->GetLevel() : 0;
+        p *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * (u2->pLfoInfo->pitch + f)) : 1;
+        
+        for (int i = 0; i < GetRack()->pitchLFOs.size(); i++) {
+            LFOv2Unit* lfo = GetRack()->pitchLFOs[i];
+            if (!lfo->Active()) continue;
+            
+            float f = lfo->suPitchOnCC.Active() ? lfo->suPitchOnCC.GetLevel() : 0;
+            p *= RTMath::CentsToFreqRatioUnlimited(lfo->GetLevel() * (lfo->pLfoInfo->pitch + f));
+        }
+        
+        return p;
     }
     
     float EndpointUnit::GetResonance() {
-        return 1;
+         float val = 0;
+        
+        for (int i = 0; i < GetRack()->resEGs.size(); i++) {
+            EGv2Unit* eg = GetRack()->resEGs[i];
+            if (!eg->Active()) continue;
+            
+            float f = eg->suResOnCC.Active() ? eg->suResOnCC.GetLevel() : 0;
+            val += eg->GetLevel() * (eg->pEGInfo->resonance + f);
+        }
+        
+        for (int i = 0; i < GetRack()->resLFOs.size(); i++) {
+            LFOv2Unit* lfo = GetRack()->resLFOs[i];
+            if (!lfo->Active()) continue;
+            
+            float f = lfo->suResOnCC.Active() ? lfo->suResOnCC.GetLevel() : 0;
+            val += lfo->GetLevel() * (lfo->pLfoInfo->resonance + f);
+        }
+        
+        return val;
+    }
+    
+    float EndpointUnit::GetPan() {
+        float pan = 0;
+        
+        for (int i = 0; i < GetRack()->panLFOs.size(); i++) {
+            LFOv2Unit* lfo = GetRack()->panLFOs[i];
+            if (!lfo->Active()) continue;
+            
+            float f = lfo->suPanOnCC.Active() ? lfo->suPanOnCC.GetLevel() : 0;
+            pan += lfo->GetLevel() * (lfo->pLfoInfo->pan + f);
+        }
+        
+        if(pan < -100) return -100;
+        if(pan >  100) return  100;
+        
+        return pan;
     }
     
     
     SfzSignalUnitRack::SfzSignalUnitRack(Voice* voice)
-        : SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this),
-        EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount)
+        : SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this), suFilEG(this), suPitchEG(this),
+        EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount), filEGs(maxEgCount), resEGs(maxEgCount), suVolOnCC(this),
+        suAmpLFO(this), suPitchLFO(this), suFilLFO(this),
+        LFOs(maxLfoCount), volLFOs(maxLfoCount), pitchLFOs(maxLfoCount),
+        filLFOs(maxLfoCount), resLFOs(maxLfoCount), panLFOs(maxLfoCount)
     {
-        suEndpoint.pVoice = suVolEG.pVoice = voice;
+        suEndpoint.pVoice = suVolEG.pVoice = suFilEG.pVoice = suPitchEG.pVoice = voice;
+        suAmpLFO.pVoice = suPitchLFO.pVoice = suFilLFO.pVoice = suVolOnCC.pVoice = voice;
+        suPitchLFO.suDepthOnCC.pVoice = suPitchLFO.suFadeEG.pVoice = suPitchLFO.suFreqOnCC.pVoice = voice;
+        suFilLFO.suFadeEG.pVoice = suFilLFO.suDepthOnCC.pVoice = suFilLFO.suFreqOnCC.pVoice = voice;
+        suAmpLFO.suFadeEG.pVoice = suAmpLFO.suDepthOnCC.pVoice = suAmpLFO.suFreqOnCC.pVoice = voice;
         
         for (int i = 0; i < EGs.capacity(); i++) {
             EGs[i] = new EGv2Unit(this);
             EGs[i]->pVoice = voice;
+            EGs[i]->suAmpOnCC.pVoice = voice;
+            EGs[i]->suVolOnCC.pVoice = voice;
+            EGs[i]->suPitchOnCC.pVoice = voice;
+            EGs[i]->suCutoffOnCC.pVoice = voice;
+            EGs[i]->suResOnCC.pVoice = voice;
+        }
+        
+        for (int i = 0; i < LFOs.capacity(); i++) {
+            LFOs[i] = new LFOv2Unit(this);
+            LFOs[i]->pVoice = voice;
+            LFOs[i]->suFadeEG.pVoice = voice;
+            LFOs[i]->suVolOnCC.pVoice = voice;
+            LFOs[i]->suPitchOnCC.pVoice = voice;
+            LFOs[i]->suFreqOnCC.pVoice = voice;
+            LFOs[i]->suPanOnCC.pVoice = voice;
+            LFOs[i]->suCutoffOnCC.pVoice = voice;
+            LFOs[i]->suResOnCC.pVoice = voice;
         }
     }
     
     SfzSignalUnitRack::~SfzSignalUnitRack() {
-        for (int i = 0; i < maxEgCount; i++) {
+        for (int i = 0; i < EGs.capacity(); i++) {
             delete EGs[i]; EGs[i] = NULL;
         }
+        
+        for (int i = 0; i < LFOs.capacity(); i++) {
+            delete LFOs[i]; LFOs[i] = NULL;
+        }
     }
     
     void SfzSignalUnitRack::Trigger() {
         EGs.clear();
         volEGs.clear();
         pitchEGs.clear();
+        filEGs.clear();
+        resEGs.clear();
+        
+        LFOs.clear();
+        volLFOs.clear();
+        pitchLFOs.clear();
+        filLFOs.clear();
+        resLFOs.clear();
+        panLFOs.clear();
         
         ::sfz::Region* const pRegion = pVoice->pRegion;
         
-        for (int i = 0 ; i < pRegion->eg.size() ; i++) {
+        suVolOnCC.SetCCs(pRegion->volume_oncc);
+        
+        for (int i = 0; i < pRegion->eg.size(); i++) {
             if (pRegion->eg[i].node.size() == 0) continue;
             
             if(EGs.size() < EGs.capacity()) {
                 EGv2Unit eg(this);
                 eg.pEGInfo = &(pRegion->eg[i]);
                 EGs.increment()->Copy(eg);
+                EGs[EGs.size() - 1]->suAmpOnCC.SetCCs(pRegion->eg[i].amplitude_oncc);
+                EGs[EGs.size() - 1]->suVolOnCC.SetCCs(pRegion->eg[i].volume_oncc);
+                EGs[EGs.size() - 1]->suPitchOnCC.SetCCs(pRegion->eg[i].pitch_oncc);
+                EGs[EGs.size() - 1]->suCutoffOnCC.SetCCs(pRegion->eg[i].cutoff_oncc);
+                EGs[EGs.size() - 1]->suResOnCC.SetCCs(pRegion->eg[i].resonance_oncc);
             } else { std::cerr << "Maximum number of EGs reached!" << std::endl; break; }
             
+            if ( pRegion->eg[i].amplitude > 0 || !pRegion->eg[i].amplitude_oncc.empty() ||
+                 pRegion->eg[i].volume > -145 || !pRegion->eg[i].volume_oncc.empty()
+            ) {
+                if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
+                else std::cerr << "Maximum number of EGs reached!" << std::endl;
+            }
+            
+            if (pRegion->eg[i].cutoff != 0 || !pRegion->eg[i].cutoff_oncc.empty()) {
+                if(filEGs.size() < filEGs.capacity()) filEGs.add(EGs[EGs.size() - 1]);
+                else std::cerr << "Maximum number of EGs reached!" << std::endl;
+            }
             
+            if (pRegion->eg[i].resonance != 0 || !pRegion->eg[i].resonance_oncc.empty()) {
+                if(resEGs.size() < resEGs.capacity()) resEGs.add(EGs[EGs.size() - 1]);
+                else std::cerr << "Maximum number of EGs reached!" << std::endl;
+            }
             
-            if (pRegion->eg[i].amplitude > 0) {
-                if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
+            if (pRegion->eg[i].pitch != 0 || !pRegion->eg[i].pitch_oncc.empty()) {
+                if(pitchEGs.size() < pitchEGs.capacity()) pitchEGs.add(EGs[EGs.size() - 1]);
                 else std::cerr << "Maximum number of EGs reached!" << std::endl;
             }
         }
@@ -148,12 +587,98 @@
             else pRegion->ampeg_sustain = 100;
         }
         
+        // LFO
+        for (int i = 0; i < pRegion->lfos.size(); i++) {
+            if (pRegion->lfos[i].freq == -1) continue; // Not initialized
+            
+            if(LFOs.size() < LFOs.capacity()) {
+                LFOv2Unit lfo(this);
+                lfo.pLfoInfo = &(pRegion->lfos[i]);
+                LFOs.increment()->Copy(lfo);
+                LFOs[LFOs.size() - 1]->suVolOnCC.SetCCs(pRegion->lfos[i].volume_oncc);
+                LFOs[LFOs.size() - 1]->suPitchOnCC.SetCCs(pRegion->lfos[i].pitch_oncc);
+                LFOs[LFOs.size() - 1]->suFreqOnCC.SetCCs(pRegion->lfos[i].freq_oncc);
+                LFOs[LFOs.size() - 1]->suPanOnCC.SetCCs(pRegion->lfos[i].pan_oncc);
+                LFOs[LFOs.size() - 1]->suCutoffOnCC.SetCCs(pRegion->lfos[i].cutoff_oncc);
+                LFOs[LFOs.size() - 1]->suResOnCC.SetCCs(pRegion->lfos[i].resonance_oncc);
+            } else { std::cerr << "Maximum number of LFOs reached!" << std::endl; break; }
+            
+            if (pRegion->lfos[i].volume != 0 || !pRegion->lfos[i].volume_oncc.empty()) {
+                if(volLFOs.size() < volLFOs.capacity()) volLFOs.add(LFOs[LFOs.size() - 1]);
+                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
+            }
+            
+            if (pRegion->lfos[i].pitch != 0 || !pRegion->lfos[i].pitch_oncc.empty()) {
+                if(pitchLFOs.size() < pitchLFOs.capacity()) pitchLFOs.add(LFOs[LFOs.size() - 1]);
+                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
+            }
+            
+            if (pRegion->lfos[i].cutoff != 0 || !pRegion->lfos[i].cutoff_oncc.empty()) {
+                if(filLFOs.size() < filLFOs.capacity()) filLFOs.add(LFOs[LFOs.size() - 1]);
+                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
+            }
+            
+            if (pRegion->lfos[i].resonance != 0 || !pRegion->lfos[i].resonance_oncc.empty()) {
+                if(resLFOs.size() < resLFOs.capacity()) resLFOs.add(LFOs[LFOs.size() - 1]);
+                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
+            }
+            
+            if (pRegion->lfos[i].pan != 0 || !pRegion->lfos[i].pan_oncc.empty()) {
+                if(panLFOs.size() < panLFOs.capacity()) panLFOs.add(LFOs[LFOs.size() - 1]);
+                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
+            }
+        }
+        
+        suPitchLFO.suDepthOnCC.SetCCs(pRegion->pitchlfo_depthcc);
+        suPitchLFO.suFreqOnCC.SetCCs(pRegion->pitchlfo_freqcc);
+        
+        suFilLFO.suDepthOnCC.SetCCs(pRegion->fillfo_depthcc);
+        suFilLFO.suFreqOnCC.SetCCs(pRegion->fillfo_freqcc);
+        
+        suAmpLFO.suDepthOnCC.SetCCs(pRegion->amplfo_depthcc);
+        suAmpLFO.suFreqOnCC.SetCCs(pRegion->amplfo_freqcc);
+        
         Units.clear();
         
+        Units.add(&suVolOnCC);
+        
         Units.add(&suVolEG);
+        Units.add(&suFilEG);
+        Units.add(&suPitchEG);
+        
+        Units.add(&suPitchLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
+        Units.add(&suPitchLFO);
+        Units.add(&suPitchLFO.suDepthOnCC);
+        Units.add(&suPitchLFO.suFadeEG);
+        
+        Units.add(&suAmpLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
+        Units.add(&suAmpLFO.suDepthOnCC);
+        Units.add(&suAmpLFO);
+        Units.add(&suAmpLFO.suFadeEG);
+        
+        Units.add(&suFilLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
+        Units.add(&suFilLFO.suDepthOnCC);
+        Units.add(&suFilLFO);
+        Units.add(&suFilLFO.suFadeEG);
         
-        for (int i = 0 ; i < EGs.size() ; i++) {
+        for (int i = 0; i < EGs.size(); i++) {
             Units.add(EGs[i]);
+            Units.add(&(EGs[i]->suAmpOnCC));
+            Units.add(&(EGs[i]->suVolOnCC));
+            Units.add(&(EGs[i]->suPitchOnCC));
+            Units.add(&(EGs[i]->suCutoffOnCC));
+            Units.add(&(EGs[i]->suResOnCC));
+        }
+        
+        for (int i = 0; i < LFOs.size(); i++) {
+            Units.add(&(LFOs[i]->suFreqOnCC)); // Don't change order! (should be triggered before the LFO)
+            Units.add(LFOs[i]);
+            Units.add(&(LFOs[i]->suFadeEG));
+            Units.add(&(LFOs[i]->suVolOnCC));
+            Units.add(&(LFOs[i]->suPitchOnCC));
+            Units.add(&(LFOs[i]->suPanOnCC));
+            Units.add(&(LFOs[i]->suCutoffOnCC));
+            Units.add(&(LFOs[i]->suResOnCC));
         }
         
         Units.add(&suEndpoint);