trunk/src/eg_vca.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck         *
 *                                                                         *
 *   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 "eg_vca.h"

EG_VCA::EG_VCA() {
    Stage = stage_end;
    Level = 0.0;
}

/**
 * Will be called by the voice for every audio fragment to let the EG
 * queue it's modulation changes for the current audio fragment.
 */
void EG_VCA::ProcessFragment() {
    if (Stage == stage_sustain) return; // nothing to do

    for (int to_process_total = ModulationSystem::GetFragmentSize(); to_process_total;) {
        int iSample = 0;
        switch (Stage) {
            case stage_attack: {
                int to_process    = Min(to_process_total, AttackStepsLeft);
                int process_end   = iSample + to_process;
                AttackStepsLeft  -= to_process;
                to_process_total -= to_process;
                for (; iSample < process_end; iSample++) {
                    Level += AttackCoeff;
                    ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
                }
                if (!AttackStepsLeft) {
                    Stage = (ReleaseSignalReceived) ? stage_release : stage_sustain;
                }
                break;
            }
            case stage_sustain: {
                return;
            }
            case stage_release: {
                int process_end = iSample + to_process_total;
                for (; iSample < process_end; iSample++) {
                    Level -= Level * ReleaseCoeff;
                    ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
                }
                if (Level <= EG_ENVELOPE_LIMIT) Stage = stage_end;
                return;
            }
            case stage_end: {
                int process_end = iSample + to_process_total;
                for (; iSample < process_end; iSample++) {
                    ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
                }
                return;
            }
        }
    }
}

/**
 * Will be called by the voice when the key / voice was triggered.
 *
 * @param PreAttack   - Preattack value for the envelope (0 - 1000 permille)
 * @param AttackTime  - Attack time for the envelope (0.000 - 60.000s)
 * @param ReleaseTIme - Release time for the envelope (0.000 - 60.000s)
 */
void EG_VCA::Trigger(uint PreAttack, double AttackTime, double ReleaseTime) {
    ReleaseSignalReceived = false;
    Stage = stage_attack;

    // calculate attack stage parameters
    AttackStepsLeft = (long) (AttackTime * ModulationSystem::GetSampleRate());
    if (AttackStepsLeft) {
        Level       = PreAttack;
        AttackCoeff = (1.0 - PreAttack) / AttackStepsLeft;
    }
    else {
        Level       = 1.0;
        AttackCoeff = 0.0;
    }

    // calcuate release stage parameters
    if (ReleaseTime < EG_MIN_RELEASE_TIME) ReleaseTime = EG_MIN_RELEASE_TIME;  // to avoid click sounds at the end of the sample playback
    ReleaseStepsLeft = (long) (ReleaseTime * ModulationSystem::GetSampleRate());
    ReleaseCoeff     = 1.0 - exp(log(EG_ENVELOPE_LIMIT) / (double) ReleaseStepsLeft);

    dmsg(4,("AttackLength=%d, ReleaseLength=%d",AttackStepsLeft,ReleaseStepsLeft));
}

/**
 * Will be called by the voice when the key / voice was released.
 */
void EG_VCA::Release() {
    // postpone release stage until sustain stage reached
    if (Stage == stage_sustain) Stage = stage_release;
    ReleaseSignalReceived = true;
}
1	schoenebeck	30	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck *
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 "eg_vca.h"
24
25			EG_VCA::EG_VCA() {
26			Stage = stage_end;
27			Level = 0.0;
28			}
29
30			/**
31			* Will be called by the voice for every audio fragment to let the EG
32			* queue it's modulation changes for the current audio fragment.
33			*/
34			void EG_VCA::ProcessFragment() {
35			if (Stage == stage_sustain) return; // nothing to do
36
37			for (int to_process_total = ModulationSystem::GetFragmentSize(); to_process_total;) {
38			int iSample = 0;
39			switch (Stage) {
40			case stage_attack: {
41			int to_process = Min(to_process_total, AttackStepsLeft);
42			int process_end = iSample + to_process;
43			AttackStepsLeft -= to_process;
44			to_process_total -= to_process;
45			for (; iSample < process_end; iSample++) {
46			Level += AttackCoeff;
47			ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
48			}
49			if (!AttackStepsLeft) {
50			Stage = (ReleaseSignalReceived) ? stage_release : stage_sustain;
51			}
52			break;
53			}
54			case stage_sustain: {
55			return;
56			}
57			case stage_release: {
58			int process_end = iSample + to_process_total;
59			for (; iSample < process_end; iSample++) {
60			Level -= Level * ReleaseCoeff;
61			ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
62			}
63			if (Level <= EG_ENVELOPE_LIMIT) Stage = stage_end;
64			return;
65			}
66			case stage_end: {
67			int process_end = iSample + to_process_total;
68			for (; iSample < process_end; iSample++) {
69			ModulationSystem::pDestinationParameter[ModulationSystem::destination_vca][iSample] *= Level;
70			}
71			return;
72			}
73			}
74			}
75			}
76
77			/**
78			* Will be called by the voice when the key / voice was triggered.
79			*
80			* @param PreAttack - Preattack value for the envelope (0 - 1000 permille)
81			* @param AttackTime - Attack time for the envelope (0.000 - 60.000s)
82			* @param ReleaseTIme - Release time for the envelope (0.000 - 60.000s)
83			*/
84			void EG_VCA::Trigger(uint PreAttack, double AttackTime, double ReleaseTime) {
85			ReleaseSignalReceived = false;
86			Stage = stage_attack;
87
88			// calculate attack stage parameters
89			AttackStepsLeft = (long) (AttackTime * ModulationSystem::GetSampleRate());
90			if (AttackStepsLeft) {
91			Level = PreAttack;
92			AttackCoeff = (1.0 - PreAttack) / AttackStepsLeft;
93			}
94			else {
95			Level = 1.0;
96			AttackCoeff = 0.0;
97			}
98
99			// calcuate release stage parameters
100			if (ReleaseTime < EG_MIN_RELEASE_TIME) ReleaseTime = EG_MIN_RELEASE_TIME; // to avoid click sounds at the end of the sample playback
101			ReleaseStepsLeft = (long) (ReleaseTime * ModulationSystem::GetSampleRate());
102			ReleaseCoeff = 1.0 - exp(log(EG_ENVELOPE_LIMIT) / (double) ReleaseStepsLeft);
103
104			dmsg(4,("AttackLength=%d, ReleaseLength=%d",AttackStepsLeft,ReleaseStepsLeft));
105			}
106
107			/**
108			* Will be called by the voice when the key / voice was released.
109			*/
110			void EG_VCA::Release() {
111			// postpone release stage until sustain stage reached
112			if (Stage == stage_sustain) Stage = stage_release;
113			ReleaseSignalReceived = true;
114			}