engines/sfz/SfzSignalUnitRack.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2011 Grigor Iliev                                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "SfzSignalUnitRack.h"
#include "Voice.h"
#include <SF.h>

namespace LinuxSampler { namespace sfz {
    
    SfzSignalUnit::SfzSignalUnit(SfzSignalUnitRack* rack): SignalUnit(rack), pVoice(rack->pVoice) {
        
    }
    
    double SfzSignalUnit::GetSampleRate() {
        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 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);

        // 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 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)
    { }
    
    LFOUnit::LFOUnit(const LFOUnit& Unit)
        : SfzSignalUnit(Unit), suFadeEG(static_cast<SfzSignalUnitRack*>(Unit.pRack)),
          suFreqOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack), this)
    {
        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 * 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),
          suPitchOnCC(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) {
        
    }
    
    SfzSignalUnitRack* const EndpointUnit::GetRack() {
        return static_cast<SfzSignalUnitRack* const>(pRack);
    }
    
    void EndpointUnit::Trigger() {
        
    }
    
    bool EndpointUnit::Active() {
        if (GetRack()->suVolEG.Active()) return true;
        
        bool b = false;
        for (int i = 0; i < GetRack()->volEGs.size(); i++) {
            if (GetRack()->volEGs[i]->Active()) { b = true; break; }
        }
        
        return b;
    }
    
    float EndpointUnit::GetVolume() {
        float vol = GetRack()->suVolEG.Active() ? GetRack()->suVolEG.GetLevel() : 0;
        
        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);
            
        }
        
        AmpLFOUnit* u = &(GetRack()->suAmpLFO);
        vol *= u->Active() ? ::sf2::ToRatio((u->GetLevel() * u->pLfoInfo->volume) * 10.0) : 1;
        
        vol *= ::sf2::ToRatio(GetRack()->suVolOnCC.GetLevel() * 10.0);
        
        return vol;
    }
    
    float EndpointUnit::GetFilterCutoff() {
        float val;
        
        FilLFOUnit* u = &(GetRack()->suFilLFO);
        val = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->pLfoInfo->cutoff) : 1;
        
        FilEGUnit* u2 = &(GetRack()->suFilEG);
        val *= u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() * u2->depth) : 1;
        
        for (int i = 0; i < GetRack()->filLFOs.size(); i++) {
            LFOv2Unit* lfo = GetRack()->filLFOs[i];
            if (!lfo->Active()) continue;
            
            float f = lfo->GetLevel() * lfo->pLfoInfo->cutoff;
            val *= RTMath::CentsToFreqRatioUnlimited(f);
        }
        
        return val;
    }
    
    float EndpointUnit::GetPitch() {
        double p;
        EGv1Unit* u = &(GetRack()->suPitchEG);
        p = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->depth) : 1;
        
        PitchLFOUnit* u2 = &(GetRack()->suPitchLFO);
        CCSignalUnit* u3 = &(GetRack()->suPitchLFO.suDepthCC);
        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() {
         float val = 0;
        
        for (int i = 0; i < GetRack()->resLFOs.size(); i++) {
            LFOv2Unit* lfo = GetRack()->resLFOs[i];
            if (!lfo->Active()) continue;
            
            val += lfo->GetLevel() * lfo->pLfoInfo->resonance;
        }
        
        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;
            
            pan += lfo->GetLevel() * lfo->pLfoInfo->pan;
        }
        
        if(pan < -100) return -100;
        if(pan >  100) return  100;
        
        return pan;
    }
    
    
    SfzSignalUnitRack::SfzSignalUnitRack(Voice* voice)
        : SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this), suFilEG(this), suPitchEG(this),
        EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount), suVolOnCC(this),
        suAmpLFO(this), suPitchLFO(this), suFilLFO(this),
        LFOs(maxLfoCount), pitchLFOs(maxLfoCount), filLFOs(maxLfoCount), resLFOs(maxLfoCount), panLFOs(maxLfoCount)
    {
        suEndpoint.pVoice = suVolEG.pVoice = suFilEG.pVoice = suPitchEG.pVoice = voice;
        suAmpLFO.pVoice = suPitchLFO.pVoice = suFilLFO.pVoice = suVolOnCC.pVoice = voice;
        suPitchLFO.suDepthCC.pVoice = suPitchLFO.suFadeEG.pVoice = suPitchLFO.suFreqOnCC.pVoice = voice;
        suFilLFO.suFadeEG.pVoice = suFilLFO.suFreqOnCC.pVoice = voice;
        suAmpLFO.suFadeEG.pVoice = suAmpLFO.suFreqOnCC.pVoice = voice;
        
        for (int i = 0; i < EGs.capacity(); i++) {
            EGs[i] = new EGv2Unit(this);
            EGs[i]->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]->suPitchOnCC.pVoice = voice;
            LFOs[i]->suFreqOnCC.pVoice = voice;
        }
    }
    
    SfzSignalUnitRack::~SfzSignalUnitRack() {
        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();
        
        LFOs.clear();
        pitchLFOs.clear();
        filLFOs.clear();
        resLFOs.clear();
        panLFOs.clear();
        
        ::sfz::Region* const pRegion = pVoice->pRegion;
        
        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);
            } else { std::cerr << "Maximum number of EGs reached!" << std::endl; break; }
            
            if (pRegion->eg[i].amplitude > 0) {
                if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
                else std::cerr << "Maximum number of EGs reached!" << std::endl;
            }
        }
        
        if (pRegion->ampeg_sustain == -1) {
            if (volEGs.size() > 0) pRegion->ampeg_sustain = 0;
            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]->suPitchOnCC.SetCCs(pRegion->lfos[i].pitch_oncc);
                LFOs[LFOs.size() - 1]->suFreqOnCC.SetCCs(pRegion->lfos[i].freq_oncc);
            } else { std::cerr << "Maximum number of LFOs reached!" << std::endl; break; }
            
            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) {
                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) {
                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) {
                if(panLFOs.size() < panLFOs.capacity()) panLFOs.add(LFOs[LFOs.size() - 1]);
                else std::cerr << "Maximum number of LFOs reached!" << std::endl;
            }
        }
        
        suPitchLFO.suDepthCC.SetCCs(pRegion->pitchlfo_depthcc);
        suPitchLFO.suFreqOnCC.SetCCs(pRegion->pitchlfo_freqcc);
        
        suFilLFO.suFreqOnCC.SetCCs(pRegion->fillfo_freqcc);
        
        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.suDepthCC);
        Units.add(&suPitchLFO.suFadeEG);
        
        Units.add(&suAmpLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
        Units.add(&suAmpLFO);
        Units.add(&suAmpLFO.suFadeEG);
        
        Units.add(&suFilLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
        Units.add(&suFilLFO);
        Units.add(&suFilLFO.suFadeEG);
        
        for (int i = 0; i < EGs.size(); i++) {
            Units.add(EGs[i]);
        }
        
        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]->suPitchOnCC));
        }
        
        Units.add(&suEndpoint);
        
        SignalUnitRack::Trigger();
    }
    
    EndpointSignalUnit* SfzSignalUnitRack::GetEndpointUnit() {
        return &suEndpoint;
    }
    
    void SfzSignalUnitRack::EnterFadeOutStage() {
        suVolEG.EG.enterFadeOutStage();
        
        for (int i = 0; i < volEGs.size(); i++) {
            volEGs[i]->EG.enterFadeOutStage();
        }
    }
    
}} // namespace LinuxSampler::sfz
1	iliev	2218	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2011 Grigor Iliev *
6			* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			#include "SfzSignalUnitRack.h"
24			#include "Voice.h"
25	iliev	2221	#include <SF.h>
26	iliev	2218
27			namespace LinuxSampler { namespace sfz {
28
29			SfzSignalUnit::SfzSignalUnit(SfzSignalUnitRack* rack): SignalUnit(rack), pVoice(rack->pVoice) {
30
31			}
32
33			double SfzSignalUnit::GetSampleRate() {
34			return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
35			}
36
37	iliev	2229	float SfzSignalUnit::GetInfluence(ArrayList< ::sfz::CC>& cc) {
38			float f = 0;
39			for (int i = 0; i < cc.size(); i++) {
40			int val = pVoice->GetControllerValue(cc[i].Controller);
41			f += (val / 127.0f) * cc[i].Influence;
42			}
43			return f;
44	iliev	2218	}
45
46	iliev	2220
47	iliev	2218	void EGv2Unit::Trigger() {
48	iliev	2229	egInfo = *pEGInfo;
49			for (int i = 0; i < egInfo.node.size(); i++) {
50			float f = GetInfluence(egInfo.node[i].level_oncc);
51			egInfo.node[i].level = std::min(egInfo.node[i].level + f, 1.0f);
52
53			f = GetInfluence(egInfo.node[i].time_oncc);
54			egInfo.node[i].time = std::min(egInfo.node[i].time + f, 100.0f);
55			}
56			EG.trigger(egInfo, GetSampleRate(), pVoice->MIDIVelocity);
57	iliev	2218	}
58	iliev	2219
59	iliev	2220
60			void PitchEGUnit::Trigger() {
61			::sfz::Region* const pRegion = pVoice->pRegion;
62			depth = pRegion->pitcheg_depth;
63
64			// the length of the decay and release curves are dependent on the velocity
65			const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
66	iliev	2218
67	iliev	2220	// set the delay trigger
68			uiDelayTrigger = (pRegion->pitcheg_delay + pRegion->pitcheg_vel2delay * velrelease) * GetSampleRate();
69
70			EG.trigger(uint(pRegion->pitcheg_start * 10),
71			std::max(0.0, pRegion->pitcheg_attack + pRegion->pitcheg_vel2attack * velrelease),
72			std::max(0.0, pRegion->pitcheg_hold + pRegion->pitcheg_vel2hold * velrelease),
73			std::max(0.0, pRegion->pitcheg_decay + pRegion->pitcheg_vel2decay * velrelease),
74			uint(std::min(std::max(0.0, 10 * (pRegion->pitcheg_sustain + pRegion->pitcheg_vel2sustain * velrelease)), 1000.0)),
75			std::max(0.0, pRegion->pitcheg_release + pRegion->pitcheg_vel2release * velrelease),
76			GetSampleRate());
77			}
78
79	iliev	2222
80			void FilEGUnit::Trigger() {
81			::sfz::Region* const pRegion = pVoice->pRegion;
82			depth = pRegion->fileg_depth;
83
84			// the length of the decay and release curves are dependent on the velocity
85			const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
86	iliev	2220
87	iliev	2222	// set the delay trigger
88			uiDelayTrigger = (pRegion->fileg_delay + pRegion->fileg_vel2delay * velrelease) * GetSampleRate();
89
90			EG.trigger(uint(pRegion->fileg_start * 10),
91			std::max(0.0, pRegion->fileg_attack + pRegion->fileg_vel2attack * velrelease),
92			std::max(0.0, pRegion->fileg_hold + pRegion->fileg_vel2hold * velrelease),
93			std::max(0.0, pRegion->fileg_decay + pRegion->fileg_vel2decay * velrelease),
94			uint(std::min(std::max(0.0, 10 * (pRegion->fileg_sustain + pRegion->fileg_vel2sustain * velrelease)), 1000.0)),
95			std::max(0.0, pRegion->fileg_release + pRegion->fileg_vel2release * velrelease),
96			GetSampleRate());
97			}
98
99	iliev	2226
100	iliev	2229	void AmpEGUnit::Trigger() {
101			::sfz::Region* const pRegion = pVoice->pRegion;
102
103			// the length of the decay and release curves are dependent on the velocity
104			const double velrelease = 1 / pVoice->GetVelocityRelease(pVoice->MIDIVelocity);
105
106			// set the delay trigger
107			float delay = pRegion->ampeg_delay + pRegion->ampeg_vel2delay * velrelease;
108			delay += GetInfluence(pRegion->ampeg_delaycc);
109			uiDelayTrigger = std::max(0.0f, delay) * GetSampleRate();
110
111			float start = (pRegion->ampeg_start + GetInfluence(pRegion->ampeg_startcc)) * 10;
112
113			float attack = pRegion->ampeg_attack + pRegion->ampeg_vel2attack * velrelease;
114			attack = std::max(0.0f, attack + GetInfluence(pRegion->ampeg_attackcc));
115
116			float hold = pRegion->ampeg_hold + pRegion->ampeg_vel2hold * velrelease;
117			hold = std::max(0.0f, hold + GetInfluence(pRegion->ampeg_holdcc));
118
119			float decay = pRegion->ampeg_decay + pRegion->ampeg_vel2decay * velrelease;
120			decay = std::max(0.0f, decay + GetInfluence(pRegion->ampeg_decaycc));
121
122			float sustain = pRegion->ampeg_sustain + pRegion->ampeg_vel2sustain * velrelease;
123			sustain = 10 * (sustain + GetInfluence(pRegion->ampeg_sustaincc));
124
125			float release = pRegion->ampeg_release + pRegion->ampeg_vel2release * velrelease;
126			release = std::max(0.0f, release + GetInfluence(pRegion->ampeg_releasecc));
127
128			EG.trigger (
129			uint(std::min(std::max(0.0f, start), 1000.0f)), attack, hold, decay,
130			uint(std::min(std::max(0.0f, sustain), 1000.0f)), release, GetSampleRate()
131			);
132			}
133
134
135	iliev	2227	LFOUnit::LFOUnit(SfzSignalUnitRack* rack)
136			: SfzSignalUnit(rack), pLfoInfo(NULL), pLFO(NULL),
137			suFadeEG(rack), suFreqOnCC(rack, this)
138			{ }
139
140			LFOUnit::LFOUnit(const LFOUnit& Unit)
141			: SfzSignalUnit(Unit), suFadeEG(static_cast<SfzSignalUnitRack*>(Unit.pRack)),
142			suFreqOnCC(static_cast<SfzSignalUnitRack*>(Unit.pRack), this)
143			{
144	iliev	2226	Copy(Unit);
145			}
146	iliev	2222
147	iliev	2219	void LFOUnit::Increment() {
148			if (DelayStage()) return;
149
150			SignalUnit::Increment();
151
152	iliev	2223	Level = pLFO->Render();
153	iliev	2226	if (suFadeEG.Active()) Level *= suFadeEG.GetLevel();
154	iliev	2219	}
155
156			void LFOUnit::Trigger() {
157			//reset
158			Level = 0;
159
160			// set the delay trigger
161	iliev	2220	uiDelayTrigger = pLfoInfo->delay * GetSampleRate();
162	iliev	2226	if(pLfoInfo->fade != 0 \|\| !pLfoInfo->fade_oncc.empty()) {
163			float f = pLfoInfo->fade;
164	iliev	2229	f += GetInfluence(pLfoInfo->fade_oncc);
165	iliev	2226
166			if (f != 0) {
167			suFadeEG.uiDelayTrigger = pLfoInfo->delay * GetSampleRate();
168			suFadeEG.EG.trigger(0, f, 0, 0, 1000, 0, GetSampleRate());
169			}
170			}
171	iliev	2219	}
172
173	iliev	2227	void LFOUnit::ValueChanged(CCSignalUnit* pUnit) {
174	iliev	2229	pLFO->SetFrequency(std::max(0.0f, suFreqOnCC.GetLevel() + pLfoInfo->freq), GetSampleRate());
175	iliev	2227	}
176
177
178	iliev	2221	void LFOv1Unit::Trigger() {
179			LFOUnit::Trigger();
180
181			lfo.trigger (
182	iliev	2227	pLfoInfo->freq + suFreqOnCC.GetLevel(),
183	iliev	2221	start_level_mid,
184			1, 0, false, GetSampleRate()
185			);
186			lfo.update(0);
187			}
188
189	iliev	2223
190			LFOv2Unit::LFOv2Unit(SfzSignalUnitRack* rack)
191			: LFOUnit(rack), lfos(8), lfo0(1200.0f), lfo1(1200.0f), lfo2(1200.0f),
192	iliev	2225	lfo3(1200.0f), lfo4(1200.0f), lfo5(1200.0f), lfo6(1200.0f), lfo7(1200.0f),
193			suPitchOnCC(rack)
194	iliev	2223	{
195			lfos.add(&lfo0);
196			lfos.add(&lfo1);
197			lfos.add(&lfo2);
198			lfos.add(&lfo3);
199			lfos.add(&lfo4);
200			lfos.add(&lfo5);
201			lfos.add(&lfo6);
202			lfos.add(&lfo7);
203			}
204
205	iliev	2219	void LFOv2Unit::Trigger() {
206			LFOUnit::Trigger();
207
208	iliev	2223	if (pLfoInfo->wave < 0 \|\| pLfoInfo->wave >= lfos.size()) pLFO = &lfo0;
209			else pLFO = lfos[pLfoInfo->wave];
210
211			pLFO->Trigger (
212	iliev	2227	pLfoInfo->freq + suFreqOnCC.GetLevel(),
213	iliev	2219	start_level_mid,
214			1, 0, false, GetSampleRate()
215			);
216	iliev	2223	pLFO->Update(0);
217	iliev	2225
218	iliev	2229	float phase = pLfoInfo->phase + GetInfluence(pLfoInfo->phase_oncc);
219	iliev	2225	if (phase != 0) pLFO->SetPhase(phase);
220	iliev	2219	}
221	iliev	2221
222			void AmpLFOUnit::Trigger() {
223			::sfz::Region* const pRegion = pVoice->pRegion;
224	iliev	2226	pLfoInfo->delay = pRegion->amplfo_delay;
225			pLfoInfo->freq = pRegion->amplfo_freq;
226			pLfoInfo->fade = pRegion->amplfo_fade;
227	iliev	2221	pLfoInfo->volume = pRegion->amplfo_depth;
228
229			LFOv1Unit::Trigger();
230			}
231
232			void PitchLFOUnit::Trigger() {
233			::sfz::Region* const pRegion = pVoice->pRegion;
234			pLfoInfo->delay = pRegion->pitchlfo_delay;
235	iliev	2226	pLfoInfo->freq = pRegion->pitchlfo_freq;
236			pLfoInfo->fade = pRegion->pitchlfo_fade;
237	iliev	2221	pLfoInfo->pitch = pRegion->pitchlfo_depth;
238
239			LFOv1Unit::Trigger();
240			}
241
242			void FilLFOUnit::Trigger() {
243			::sfz::Region* const pRegion = pVoice->pRegion;
244	iliev	2226	pLfoInfo->delay = pRegion->fillfo_delay;
245			pLfoInfo->freq = pRegion->fillfo_freq;
246			pLfoInfo->fade = pRegion->fillfo_fade;
247	iliev	2221	pLfoInfo->cutoff = pRegion->fillfo_depth;
248
249			LFOv1Unit::Trigger();
250			}
251	iliev	2224
252	iliev	2227	CCUnit::CCUnit(SfzSignalUnitRack* rack, Listener* l): CCSignalUnit(rack, l) {
253			pVoice = NULL;
254			}
255	iliev	2224
256			void CCUnit::Trigger() {
257			for (int i = 0; i < Ctrls.size(); i++) {
258			Ctrls[i].Value = pVoice->GetControllerValue(Ctrls[i].Controller);
259	iliev	2232	if (Ctrls[i].pSmoother != NULL) Ctrls[i].pSmoother->setValue(Ctrls[i].Value);
260	iliev	2224	}
261			CCSignalUnit::Trigger();
262			}
263
264			void CCUnit::SetCCs(::sfz::Array<int>& cc) {
265			RemoveAllCCs();
266			for (int i = 0; i < 128; i++) {
267			if (cc[i] != 0) AddCC(i, cc[i]);
268			}
269			}
270	iliev	2225
271			void CCUnit::SetCCs(ArrayList< ::sfz::CC>& cc) {
272			RemoveAllCCs();
273			for (int i = 0; i < cc.size(); i++) {
274	iliev	2230	if (cc[i].Influence != 0) {
275			short int curve = cc[i].Curve;
276			if (curve >= GetCurveCount()) curve = -1;
277	iliev	2232	AddSmoothCC(cc[i].Controller, cc[i].Influence, curve, cc[i].Smooth);
278	iliev	2230	}
279	iliev	2225	}
280			}
281	iliev	2230
282	iliev	2232	void CCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
283			AddCC(Controller, Influence, Curve);
284			}
285
286	iliev	2230	int CCUnit::GetCurveCount() {
287			return pVoice->pRegion->GetInstrument()->curves.size();
288			}
289
290			::sfz::Curve* CCUnit::GetCurve(int idx) {
291			return &pVoice->pRegion->GetInstrument()->curves[idx];
292			}
293	iliev	2232
294			double CCUnit::GetSampleRate() {
295			return pVoice->GetSampleRate() / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
296			}
297
298			void SmoothCCUnit::AddSmoothCC(uint8_t Controller, float Influence, short int Curve, float Smooth) {
299			if (Smooth > 0) {
300			Smoothers[Controller].trigger(Smooth / 1000.0f, GetSampleRate());
301			AddCC(Controller, Influence, Curve, &Smoothers[Controller]);
302			} else {
303			AddCC(Controller, Influence, Curve);
304			}
305			}
306	iliev	2218
307	iliev	2219
308	iliev	2218	EndpointUnit::EndpointUnit(SfzSignalUnitRack* rack): EndpointSignalUnit(rack) {
309
310			}
311
312			SfzSignalUnitRack* const EndpointUnit::GetRack() {
313			return static_cast<SfzSignalUnitRack* const>(pRack);
314			}
315
316			void EndpointUnit::Trigger() {
317
318			}
319
320			bool EndpointUnit::Active() {
321			if (GetRack()->suVolEG.Active()) return true;
322
323			bool b = false;
324			for (int i = 0; i < GetRack()->volEGs.size(); i++) {
325			if (GetRack()->volEGs[i]->Active()) { b = true; break; }
326			}
327
328			return b;
329			}
330
331			float EndpointUnit::GetVolume() {
332			float vol = GetRack()->suVolEG.Active() ? GetRack()->suVolEG.GetLevel() : 0;
333
334			for (int i = 0; i < GetRack()->volEGs.size(); i++) {
335			EGv2Unit* eg = GetRack()->volEGs[i];
336			if (!eg->Active()) continue;
337			vol += eg->GetLevel() * (eg->pEGInfo->amplitude / 100.0f);
338	iliev	2229
339	iliev	2218	}
340
341	iliev	2221	AmpLFOUnit* u = &(GetRack()->suAmpLFO);
342			vol = u->Active() ? ::sf2::ToRatio((u->GetLevel() u->pLfoInfo->volume) * 10.0) : 1;
343
344	iliev	2230	vol = ::sf2::ToRatio(GetRack()->suVolOnCC.GetLevel() 10.0);
345
346	iliev	2218	return vol;
347			}
348
349			float EndpointUnit::GetFilterCutoff() {
350	iliev	2221	float val;
351	iliev	2219
352	iliev	2221	FilLFOUnit* u = &(GetRack()->suFilLFO);
353			val = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->pLfoInfo->cutoff) : 1;
354
355	iliev	2222	FilEGUnit* u2 = &(GetRack()->suFilEG);
356			val = u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() u2->depth) : 1;
357
358	iliev	2219	for (int i = 0; i < GetRack()->filLFOs.size(); i++) {
359			LFOv2Unit* lfo = GetRack()->filLFOs[i];
360			if (!lfo->Active()) continue;
361
362			float f = lfo->GetLevel() * lfo->pLfoInfo->cutoff;
363			val *= RTMath::CentsToFreqRatioUnlimited(f);
364			}
365
366			return val;
367	iliev	2218	}
368
369			float EndpointUnit::GetPitch() {
370	iliev	2221	double p;
371	iliev	2220	EGv1Unit* u = &(GetRack()->suPitchEG);
372	iliev	2221	p = u->Active() ? RTMath::CentsToFreqRatioUnlimited(u->GetLevel() * u->depth) : 1;
373
374			PitchLFOUnit* u2 = &(GetRack()->suPitchLFO);
375	iliev	2224	CCSignalUnit* u3 = &(GetRack()->suPitchLFO.suDepthCC);
376			float f = u3->Active() ? u3->GetLevel() : 0;
377			p = u2->Active() ? RTMath::CentsToFreqRatioUnlimited(u2->GetLevel() (u2->pLfoInfo->pitch + f)) : 1;
378	iliev	2225
379			for (int i = 0; i < GetRack()->pitchLFOs.size(); i++) {
380			LFOv2Unit* lfo = GetRack()->pitchLFOs[i];
381			if (!lfo->Active()) continue;
382
383			float f = lfo->suPitchOnCC.Active() ? lfo->suPitchOnCC.GetLevel() : 0;
384			p = RTMath::CentsToFreqRatioUnlimited(lfo->GetLevel() (lfo->pLfoInfo->pitch + f));
385			}
386
387	iliev	2221	return p;
388	iliev	2218	}
389
390			float EndpointUnit::GetResonance() {
391	iliev	2219	float val = 0;
392
393			for (int i = 0; i < GetRack()->resLFOs.size(); i++) {
394			LFOv2Unit* lfo = GetRack()->resLFOs[i];
395			if (!lfo->Active()) continue;
396
397			val += lfo->GetLevel() * lfo->pLfoInfo->resonance;
398			}
399
400			return val;
401	iliev	2218	}
402
403	iliev	2219	float EndpointUnit::GetPan() {
404			float pan = 0;
405
406			for (int i = 0; i < GetRack()->panLFOs.size(); i++) {
407			LFOv2Unit* lfo = GetRack()->panLFOs[i];
408			if (!lfo->Active()) continue;
409
410			pan += lfo->GetLevel() * lfo->pLfoInfo->pan;
411			}
412
413			if(pan < -100) return -100;
414			if(pan > 100) return 100;
415
416			return pan;
417			}
418	iliev	2218
419	iliev	2219
420	iliev	2218	SfzSignalUnitRack::SfzSignalUnitRack(Voice* voice)
421	iliev	2222	: SignalUnitRack(MaxUnitCount), pVoice(voice), suEndpoint(this), suVolEG(this), suFilEG(this), suPitchEG(this),
422	iliev	2230	EGs(maxEgCount), volEGs(maxEgCount), pitchEGs(maxEgCount), suVolOnCC(this),
423	iliev	2221	suAmpLFO(this), suPitchLFO(this), suFilLFO(this),
424	iliev	2225	LFOs(maxLfoCount), pitchLFOs(maxLfoCount), filLFOs(maxLfoCount), resLFOs(maxLfoCount), panLFOs(maxLfoCount)
425	iliev	2218	{
426	iliev	2222	suEndpoint.pVoice = suVolEG.pVoice = suFilEG.pVoice = suPitchEG.pVoice = voice;
427	iliev	2230	suAmpLFO.pVoice = suPitchLFO.pVoice = suFilLFO.pVoice = suVolOnCC.pVoice = voice;
428	iliev	2227	suPitchLFO.suDepthCC.pVoice = suPitchLFO.suFadeEG.pVoice = suPitchLFO.suFreqOnCC.pVoice = voice;
429			suFilLFO.suFadeEG.pVoice = suFilLFO.suFreqOnCC.pVoice = voice;
430			suAmpLFO.suFadeEG.pVoice = suAmpLFO.suFreqOnCC.pVoice = voice;
431	iliev	2218
432			for (int i = 0; i < EGs.capacity(); i++) {
433			EGs[i] = new EGv2Unit(this);
434			EGs[i]->pVoice = voice;
435			}
436	iliev	2219
437			for (int i = 0; i < LFOs.capacity(); i++) {
438			LFOs[i] = new LFOv2Unit(this);
439			LFOs[i]->pVoice = voice;
440	iliev	2226	LFOs[i]->suFadeEG.pVoice = voice;
441	iliev	2225	LFOs[i]->suPitchOnCC.pVoice = voice;
442	iliev	2227	LFOs[i]->suFreqOnCC.pVoice = voice;
443	iliev	2219	}
444	iliev	2218	}
445
446			SfzSignalUnitRack::~SfzSignalUnitRack() {
447	iliev	2219	for (int i = 0; i < EGs.capacity(); i++) {
448	iliev	2218	delete EGs[i]; EGs[i] = NULL;
449			}
450	iliev	2219
451			for (int i = 0; i < LFOs.capacity(); i++) {
452			delete LFOs[i]; LFOs[i] = NULL;
453			}
454	iliev	2218	}
455
456			void SfzSignalUnitRack::Trigger() {
457			EGs.clear();
458			volEGs.clear();
459			pitchEGs.clear();
460
461	iliev	2219	LFOs.clear();
462	iliev	2225	pitchLFOs.clear();
463	iliev	2219	filLFOs.clear();
464			resLFOs.clear();
465			panLFOs.clear();
466
467	iliev	2218	::sfz::Region* const pRegion = pVoice->pRegion;
468
469	iliev	2230	suVolOnCC.SetCCs(pRegion->volume_oncc);
470
471	iliev	2219	for (int i = 0; i < pRegion->eg.size(); i++) {
472	iliev	2218	if (pRegion->eg[i].node.size() == 0) continue;
473
474			if(EGs.size() < EGs.capacity()) {
475			EGv2Unit eg(this);
476			eg.pEGInfo = &(pRegion->eg[i]);
477			EGs.increment()->Copy(eg);
478			} else { std::cerr << "Maximum number of EGs reached!" << std::endl; break; }
479
480			if (pRegion->eg[i].amplitude > 0) {
481			if(volEGs.size() < volEGs.capacity()) volEGs.add(EGs[EGs.size() - 1]);
482			else std::cerr << "Maximum number of EGs reached!" << std::endl;
483			}
484			}
485
486			if (pRegion->ampeg_sustain == -1) {
487			if (volEGs.size() > 0) pRegion->ampeg_sustain = 0;
488			else pRegion->ampeg_sustain = 100;
489			}
490
491	iliev	2219	// LFO
492			for (int i = 0; i < pRegion->lfos.size(); i++) {
493			if (pRegion->lfos[i].freq == -1) continue; // Not initialized
494
495			if(LFOs.size() < LFOs.capacity()) {
496			LFOv2Unit lfo(this);
497			lfo.pLfoInfo = &(pRegion->lfos[i]);
498			LFOs.increment()->Copy(lfo);
499	iliev	2225	LFOs[LFOs.size() - 1]->suPitchOnCC.SetCCs(pRegion->lfos[i].pitch_oncc);
500	iliev	2227	LFOs[LFOs.size() - 1]->suFreqOnCC.SetCCs(pRegion->lfos[i].freq_oncc);
501	iliev	2219	} else { std::cerr << "Maximum number of LFOs reached!" << std::endl; break; }
502
503	iliev	2225	if (pRegion->lfos[i].pitch != 0 \|\| !pRegion->lfos[i].pitch_oncc.empty()) {
504			if(pitchLFOs.size() < pitchLFOs.capacity()) pitchLFOs.add(LFOs[LFOs.size() - 1]);
505			else std::cerr << "Maximum number of LFOs reached!" << std::endl;
506			}
507
508	iliev	2219	if (pRegion->lfos[i].cutoff != 0) {
509			if(filLFOs.size() < filLFOs.capacity()) filLFOs.add(LFOs[LFOs.size() - 1]);
510			else std::cerr << "Maximum number of LFOs reached!" << std::endl;
511			}
512
513			if (pRegion->lfos[i].resonance != 0) {
514			if(resLFOs.size() < resLFOs.capacity()) resLFOs.add(LFOs[LFOs.size() - 1]);
515			else std::cerr << "Maximum number of LFOs reached!" << std::endl;
516			}
517
518			if (pRegion->lfos[i].pan != 0) {
519			if(panLFOs.size() < panLFOs.capacity()) panLFOs.add(LFOs[LFOs.size() - 1]);
520			else std::cerr << "Maximum number of LFOs reached!" << std::endl;
521			}
522			}
523
524	iliev	2224	suPitchLFO.suDepthCC.SetCCs(pRegion->pitchlfo_depthcc);
525	iliev	2227	suPitchLFO.suFreqOnCC.SetCCs(pRegion->pitchlfo_freqcc);
526	iliev	2224
527	iliev	2227	suFilLFO.suFreqOnCC.SetCCs(pRegion->fillfo_freqcc);
528
529			suAmpLFO.suFreqOnCC.SetCCs(pRegion->amplfo_freqcc);
530
531	iliev	2218	Units.clear();
532
533	iliev	2230	Units.add(&suVolOnCC);
534
535	iliev	2218	Units.add(&suVolEG);
536	iliev	2222	Units.add(&suFilEG);
537	iliev	2220	Units.add(&suPitchEG);
538	iliev	2227
539			Units.add(&suPitchLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
540	iliev	2221	Units.add(&suPitchLFO);
541	iliev	2224	Units.add(&suPitchLFO.suDepthCC);
542	iliev	2226	Units.add(&suPitchLFO.suFadeEG);
543	iliev	2227
544			Units.add(&suAmpLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
545	iliev	2221	Units.add(&suAmpLFO);
546	iliev	2226	Units.add(&suAmpLFO.suFadeEG);
547	iliev	2227
548			Units.add(&suFilLFO.suFreqOnCC); // Don't change order! (should be triggered before the LFO)
549	iliev	2221	Units.add(&suFilLFO);
550	iliev	2226	Units.add(&suFilLFO.suFadeEG);
551	iliev	2218
552	iliev	2219	for (int i = 0; i < EGs.size(); i++) {
553	iliev	2218	Units.add(EGs[i]);
554			}
555
556	iliev	2219	for (int i = 0; i < LFOs.size(); i++) {
557	iliev	2227	Units.add(&(LFOs[i]->suFreqOnCC)); // Don't change order! (should be triggered before the LFO)
558	iliev	2219	Units.add(LFOs[i]);
559	iliev	2226	Units.add(&(LFOs[i]->suFadeEG));
560	iliev	2225	Units.add(&(LFOs[i]->suPitchOnCC));
561	iliev	2219	}
562
563	iliev	2218	Units.add(&suEndpoint);
564
565			SignalUnitRack::Trigger();
566			}
567
568			EndpointSignalUnit* SfzSignalUnitRack::GetEndpointUnit() {
569			return &suEndpoint;
570			}
571
572			void SfzSignalUnitRack::EnterFadeOutStage() {
573			suVolEG.EG.enterFadeOutStage();
574
575			for (int i = 0; i < volEGs.size(); i++) {
576			volEGs[i]->EG.enterFadeOutStage();
577			}
578			}
579
580			}} // namespace LinuxSampler::sfz