engines/gig/EGADSR.cpp

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

#include "../../common/global_private.h"

namespace LinuxSampler { namespace gig {

    EGADSR::EGADSR() {
        enterEndStage();
        Level = 0.0;
        CalculateFadeOutCoeff(CONFIG_EG_MIN_RELEASE_TIME, 44100.0); // even if the sample rate will be 192kHz it won't hurt at all
    }

    void EGADSR::CalculateFadeOutCoeff(float FadeOutTime, float SampleRate) {
        const float killSteps = FadeOutTime * SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
        FadeOutCoeff = -1.0f / killSteps;
    }

    void EGADSR::update(event_t Event, uint SampleRate) {
        if (Event == event_hold_end) HoldAttack = false;

        switch (Stage) {
            case stage_attack:
                switch (Event) {
                    case event_release:
                        enterReleasePart1Stage();
                        break;
                    case event_stage_end:
                        if (HoldAttack)
                            enterAttackHoldStage();
                        else
                            enterDecay1Part1Stage(SampleRate);
                        break;
                }
                break;
            case stage_attack_hold:
                switch (Event) {
                    case event_stage_end: {// just refresh time
                        const int intMax = (unsigned int) -1 >> 1;
                        StepsLeft = intMax; // we use the highest possible value
                        break;
                    }
                    case event_hold_end:
                        enterDecay1Part1Stage(SampleRate);
                        break;
                    case event_release:
                        enterReleasePart1Stage();
                        break;
                }
                break;
            case stage_decay1_part1:
                switch (Event) {
                    case event_stage_end:
                        enterDecay1Part2Stage(SampleRate);
                        break;
                    case event_cancel_release:
                        if (InfiniteSustain)
                            enterSustainStage();
                        else
                            enterDecay2Stage(SampleRate);
                        break;
                }
                break;
            case stage_decay1_part2:
                switch (Event) {
                    case event_release:
                        enterReleasePart1Stage();
                        break;
                    case event_stage_end:
                        if (Level < CONFIG_EG_BOTTOM)
                            enterEndStage();
                        else if (InfiniteSustain)
                            enterSustainStage();
                        else
                            enterDecay2Stage(SampleRate);
                        break;
                }
                break;
            case stage_decay2:
                switch (Event) {
                    case event_stage_end:
                        enterFadeOutStage();
                        break;
                    case event_release:
                        enterReleasePart1Stage();
                        break;
                    case event_hold_end:
                        enterDecay1Part1Stage(SampleRate);
                        break;
                }
                break;
            case stage_sustain:
                switch (Event) {
                    case event_stage_end: {// just refresh time
                        const int intMax = (unsigned int) -1 >> 1;
                        StepsLeft = intMax; // we use the highest possible value
                        break;
                    }
                    case event_release:
                        enterReleasePart1Stage();
                        break;
                    case event_hold_end:
                        enterDecay1Part1Stage(SampleRate);
                        break;
                }
                break;
            case stage_release_part1:
                switch (Event) {
                    case event_stage_end:
                        enterReleasePart2Stage();
                        break;
                    case event_cancel_release:
                        if (InfiniteSustain)
                            enterSustainStage();
                        else
                            enterDecay2Stage(SampleRate);
                        break;
                }
                break;
            case stage_release_part2:
                switch (Event) {
                    case event_stage_end:
                        enterFadeOutStage();
                        break;
                    case event_cancel_release:
                        if (InfiniteSustain)
                            enterSustainStage();
                        else
                            enterDecay2Stage(SampleRate);
                        break;
                }
                break;
            case stage_fadeout:
                switch (Event) {
                    case event_stage_end:
                        enterEndStage();
                        break;
                }
                break;
        }
    }

    void EGADSR::trigger(uint PreAttack, float AttackTime, bool HoldAttack, float Decay1Time, double Decay2Time, bool InfiniteSustain, uint SustainLevel, float ReleaseTime, float Volume, uint SampleRate) {
        this->SustainLevel     = SustainLevel / 1000.0;
        this->InfiniteSustain  = InfiniteSustain;
        this->HoldAttack       = HoldAttack;

        this->Decay1Time = Decay1Time;
        this->Decay2Time = Decay2Time;

        invVolume = 1 / Volume;
        ExpOffset = (0.25 - 1 / 3.55) * invVolume;

        // calculate release stage parameters (lin+exp curve)
        if (ReleaseTime < CONFIG_EG_MIN_RELEASE_TIME) ReleaseTime = CONFIG_EG_MIN_RELEASE_TIME;  // to avoid click sounds at the end of the sample playback
        const float ReleaseStepsLeft = (long) (ReleaseTime * SampleRate);
        ReleaseSlope  = 1.365 * (0 - 1) / ReleaseStepsLeft;
        ReleaseCoeff  = ReleaseSlope * invVolume;
        ReleaseSlope  *= 3.55;
        ReleaseCoeff2 = exp(ReleaseSlope);
        ReleaseCoeff3 = ExpOffset * (1 - ReleaseCoeff2);
        ReleaseLevel2 = 0.25 * invVolume;

        enterAttackStage(PreAttack, AttackTime, SampleRate);
    }

    void EGADSR::enterAttackStage(const uint PreAttack, const float AttackTime, const uint SampleRate) {
        Stage   = stage_attack;
        Segment = segment_lin;

        if (AttackTime >= 0.0005f) {
            // Measurements of GSt output shows that the real attack time
            // is about 65.5% of the value specified in the gig file.
            // The minimum attack value used is 0.032.
            StepsLeft = int(0.655f * RTMath::Max(AttackTime, 0.032f) * SampleRate);
            Level = (float) PreAttack / 1000.0;
            Coeff = 0.896f * (1.0f - Level) / StepsLeft; // max level is a bit lower if attack != 0
        } else { // attack is zero - immediately jump to the next stage
            Level = 1.029f; // a bit higher than max sustain
            if (HoldAttack) enterAttackHoldStage();
            else            enterDecay1Part1Stage(SampleRate);
        }
    }

    void EGADSR::enterAttackHoldStage() {
        Stage     = stage_attack_hold;
        Segment   = segment_lin;
        Coeff     = 0.0f; // don't rise anymore
        const int intMax = (unsigned int) -1 >> 1;
        StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
    }

    void EGADSR::enterDecay1Part1Stage(const uint SampleRate) {
        // The decay1 and release stage both consist of two parts,
        // first a linear curve, f, followed by an exponential curve,
        // g:
        //
        // f(x + d) = f(x) + Coeff
        // g(x + d) = Coeff2 * g(x) + Coeff3
        //
        // (where d is 1/SampleRate). The transition from f to g is
        // done when f(x) has reached Level2 = 25% of full volume.
        StepsLeft = (int) (Decay1Time * SampleRate);
        if (StepsLeft && Level > SustainLevel) {
            Stage        = stage_decay1_part1;
            Segment      = segment_lin;
            Decay1Slope = (1.347f * SustainLevel - 1.361f) / StepsLeft;
            Coeff        = Decay1Slope * invVolume;
            Decay1Level2 = 0.25 * invVolume;
            StepsLeft = int((RTMath::Max(Decay1Level2, SustainLevel) - Level) / Coeff);
            if (StepsLeft <= 0) enterDecay1Part2Stage(SampleRate);
        } else {
            if (InfiniteSustain) enterSustainStage();
            else                 enterDecay2Stage(SampleRate);
        }
    }

    void EGADSR::enterDecay1Part2Stage(const uint SampleRate) {
        if (SustainLevel < Decay1Level2) {
            Stage   = stage_decay1_part2;
            Segment = segment_exp;
            Decay1Slope *= 3.55;
            Coeff  = exp(Decay1Slope);
            Offset = ExpOffset * (1 - Coeff);
            StepsLeft = int(log((SustainLevel - ExpOffset) / (Level - ExpOffset)) / Decay1Slope);
            if (StepsLeft > 0) return;
        }
        if (InfiniteSustain) enterSustainStage();
        else                 enterDecay2Stage(SampleRate);
    }

    void EGADSR::enterDecay2Stage(const uint SampleRate) {
        Stage      = stage_decay2;
        Segment    = segment_lin;
        Decay2Time = RTMath::Max(Decay2Time, 0.05f);
        StepsLeft  = (int) (Decay2Time * SampleRate);
        Coeff      = (-1.03 / StepsLeft) * invVolume;
        //FIXME: do we really have to calculate 'StepsLeft' two times?
        StepsLeft  = int((CONFIG_EG_BOTTOM - Level) / Coeff);
        if (StepsLeft <= 0) enterEndStage();
    }

    void EGADSR::enterSustainStage() {
        Stage   = stage_sustain;
        Segment = segment_lin;
        Coeff   = 0.0f; // don't change the envelope level in this stage
        const int intMax = (unsigned int) -1 >> 1;
        StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
    }

    void EGADSR::enterReleasePart1Stage() {
        Stage     = stage_release_part1;
        Segment   = segment_lin;
        StepsLeft = int((ReleaseLevel2 - Level) / ReleaseCoeff);
        Coeff     = ReleaseCoeff;
        if (StepsLeft <= 0) enterReleasePart2Stage();
    }

    void EGADSR::enterReleasePart2Stage() {
        Stage     = stage_release_part2;
        Segment   = segment_exp;
        StepsLeft = int(log((CONFIG_EG_BOTTOM - ExpOffset) / (Level - ExpOffset)) / ReleaseSlope);
        Coeff     = ReleaseCoeff2;
        Offset    = ReleaseCoeff3;
        if (StepsLeft <= 0) enterFadeOutStage();
    }

    void EGADSR::enterFadeOutStage() {
        Stage     = stage_fadeout;
        Segment   = segment_lin;
        StepsLeft = int(Level / (-FadeOutCoeff));
        Coeff     = FadeOutCoeff;
        if (StepsLeft <= 0) enterEndStage();
    }

    void EGADSR::enterFadeOutStage(int maxFadeOutSteps) {
        Stage     = stage_fadeout;
        Segment   = segment_lin;
        StepsLeft = int(Level / (-FadeOutCoeff));
        if (StepsLeft > maxFadeOutSteps) {
            StepsLeft = maxFadeOutSteps;
            Coeff = -Level / maxFadeOutSteps;
        } else {
            Coeff = FadeOutCoeff;
        }
        if (StepsLeft <= 0) enterEndStage();
    }

    void EGADSR::enterEndStage() {
        Stage   = stage_end;
        Segment = segment_end;
        Level   = 0;
    }

}} // namespace LinuxSampler::gig
1	schoenebeck	53	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5	schoenebeck	56	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	persson	1906	* Copyright (C) 2005 - 2009 Christian Schoenebeck *
7	schoenebeck	53	* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#include "EGADSR.h"
25
26	schoenebeck	1424	#include "../../common/global_private.h"
27
28	schoenebeck	53	namespace LinuxSampler { namespace gig {
29
30	schoenebeck	738	EGADSR::EGADSR() {
31			enterEndStage();
32			Level = 0.0;
33			CalculateFadeOutCoeff(CONFIG_EG_MIN_RELEASE_TIME, 44100.0); // even if the sample rate will be 192kHz it won't hurt at all
34			}
35
36	schoenebeck	688	void EGADSR::CalculateFadeOutCoeff(float FadeOutTime, float SampleRate) {
37	persson	796	const float killSteps = FadeOutTime * SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
38	schoenebeck	688	FadeOutCoeff = -1.0f / killSteps;
39	schoenebeck	239	}
40
41	persson	783	void EGADSR::update(event_t Event, uint SampleRate) {
42			if (Event == event_hold_end) HoldAttack = false;
43
44	schoenebeck	738	switch (Stage) {
45			case stage_attack:
46	persson	783	switch (Event) {
47			case event_release:
48	schoenebeck	738	enterReleasePart1Stage();
49	persson	783	break;
50			case event_stage_end:
51			if (HoldAttack)
52			enterAttackHoldStage();
53			else
54			enterDecay1Part1Stage(SampleRate);
55			break;
56	schoenebeck	53	}
57	schoenebeck	738	break;
58			case stage_attack_hold:
59			switch (Event) {
60	persson	783	case event_stage_end: {// just refresh time
61			const int intMax = (unsigned int) -1 >> 1;
62			StepsLeft = intMax; // we use the highest possible value
63			break;
64			}
65			case event_hold_end:
66	schoenebeck	738	enterDecay1Part1Stage(SampleRate);
67	schoenebeck	53	break;
68	schoenebeck	738	case event_release:
69			enterReleasePart1Stage();
70			break;
71	schoenebeck	53	}
72	schoenebeck	738	break;
73			case stage_decay1_part1:
74			switch (Event) {
75	persson	768	case event_stage_end:
76			enterDecay1Part2Stage(SampleRate);
77	persson	614	break;
78	schoenebeck	738	case event_cancel_release:
79			if (InfiniteSustain)
80			enterSustainStage();
81			else
82			enterDecay2Stage(SampleRate);
83			break;
84	persson	614	}
85	schoenebeck	738	break;
86			case stage_decay1_part2:
87			switch (Event) {
88			case event_release:
89			enterReleasePart1Stage();
90			break;
91	persson	1906	case event_stage_end:
92	persson	783	if (Level < CONFIG_EG_BOTTOM)
93			enterEndStage();
94			else if (InfiniteSustain)
95	schoenebeck	738	enterSustainStage();
96			else
97			enterDecay2Stage(SampleRate);
98			break;
99	schoenebeck	53	}
100	schoenebeck	738	break;
101			case stage_decay2:
102			switch (Event) {
103			case event_stage_end:
104			enterFadeOutStage();
105			break;
106			case event_release:
107			enterReleasePart1Stage();
108			break;
109	persson	783	case event_hold_end:
110			enterDecay1Part1Stage(SampleRate);
111			break;
112	persson	614	}
113	schoenebeck	738	break;
114			case stage_sustain:
115			switch (Event) {
116			case event_stage_end: {// just refresh time
117			const int intMax = (unsigned int) -1 >> 1;
118			StepsLeft = intMax; // we use the highest possible value
119			break;
120	schoenebeck	53	}
121	schoenebeck	738	case event_release:
122			enterReleasePart1Stage();
123			break;
124	persson	783	case event_hold_end:
125			enterDecay1Part1Stage(SampleRate);
126			break;
127	schoenebeck	53	}
128	schoenebeck	738	break;
129			case stage_release_part1:
130			switch (Event) {
131			case event_stage_end:
132			enterReleasePart2Stage();
133			break;
134			case event_cancel_release:
135			if (InfiniteSustain)
136			enterSustainStage();
137			else
138			enterDecay2Stage(SampleRate);
139			break;
140	schoenebeck	53	}
141	schoenebeck	738	break;
142			case stage_release_part2:
143			switch (Event) {
144			case event_stage_end:
145			enterFadeOutStage();
146			break;
147			case event_cancel_release:
148			if (InfiniteSustain)
149			enterSustainStage();
150			else
151			enterDecay2Stage(SampleRate);
152			break;
153	schoenebeck	53	}
154	schoenebeck	738	break;
155			case stage_fadeout:
156			switch (Event) {
157			case event_stage_end:
158			enterEndStage();
159			break;
160	persson	614	}
161	schoenebeck	738	break;
162	schoenebeck	53	}
163			}
164
165	persson	783	void EGADSR::trigger(uint PreAttack, float AttackTime, bool HoldAttack, float Decay1Time, double Decay2Time, bool InfiniteSustain, uint SustainLevel, float ReleaseTime, float Volume, uint SampleRate) {
166			this->SustainLevel = SustainLevel / 1000.0;
167	schoenebeck	53	this->InfiniteSustain = InfiniteSustain;
168			this->HoldAttack = HoldAttack;
169
170	schoenebeck	738	this->Decay1Time = Decay1Time;
171			this->Decay2Time = Decay2Time;
172	persson	614
173	schoenebeck	738	invVolume = 1 / Volume;
174			ExpOffset = (0.25 - 1 / 3.55) * invVolume;
175
176			// calculate release stage parameters (lin+exp curve)
177			if (ReleaseTime < CONFIG_EG_MIN_RELEASE_TIME) ReleaseTime = CONFIG_EG_MIN_RELEASE_TIME; // to avoid click sounds at the end of the sample playback
178			const float ReleaseStepsLeft = (long) (ReleaseTime * SampleRate);
179			ReleaseSlope = 1.365 * (0 - 1) / ReleaseStepsLeft;
180			ReleaseCoeff = ReleaseSlope * invVolume;
181			ReleaseSlope *= 3.55;
182			ReleaseCoeff2 = exp(ReleaseSlope);
183			ReleaseCoeff3 = ExpOffset * (1 - ReleaseCoeff2);
184			ReleaseLevel2 = 0.25 * invVolume;
185	persson	768
186	persson	783	enterAttackStage(PreAttack, AttackTime, SampleRate);
187	schoenebeck	738	}
188
189	persson	783	void EGADSR::enterAttackStage(const uint PreAttack, const float AttackTime, const uint SampleRate) {
190	schoenebeck	738	Stage = stage_attack;
191			Segment = segment_lin;
192	persson	797
193			if (AttackTime >= 0.0005f) {
194			// Measurements of GSt output shows that the real attack time
195			// is about 65.5% of the value specified in the gig file.
196			// The minimum attack value used is 0.032.
197			StepsLeft = int(0.655f * RTMath::Max(AttackTime, 0.032f) * SampleRate);
198	schoenebeck	738	Level = (float) PreAttack / 1000.0;
199			Coeff = 0.896f * (1.0f - Level) / StepsLeft; // max level is a bit lower if attack != 0
200	persson	797	} else { // attack is zero - immediately jump to the next stage
201	persson	1046	Level = 1.029f; // a bit higher than max sustain
202	persson	783	if (HoldAttack) enterAttackHoldStage();
203	schoenebeck	738	else enterDecay1Part1Stage(SampleRate);
204	schoenebeck	53	}
205	schoenebeck	738	}
206	schoenebeck	53
207	persson	783	void EGADSR::enterAttackHoldStage() {
208	schoenebeck	738	Stage = stage_attack_hold;
209			Segment = segment_lin;
210			Coeff = 0.0f; // don't rise anymore
211	persson	783	const int intMax = (unsigned int) -1 >> 1;
212			StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
213	schoenebeck	738	}
214	persson	614
215	schoenebeck	738	void EGADSR::enterDecay1Part1Stage(const uint SampleRate) {
216	persson	614	// The decay1 and release stage both consist of two parts,
217			// first a linear curve, f, followed by an exponential curve,
218			// g:
219			//
220			// f(x + d) = f(x) + Coeff
221			// g(x + d) = Coeff2 * g(x) + Coeff3
222			//
223			// (where d is 1/SampleRate). The transition from f to g is
224			// done when f(x) has reached Level2 = 25% of full volume.
225	schoenebeck	738	StepsLeft = (int) (Decay1Time * SampleRate);
226	persson	1046	if (StepsLeft && Level > SustainLevel) {
227	schoenebeck	738	Stage = stage_decay1_part1;
228			Segment = segment_lin;
229	persson	1046	Decay1Slope = (1.347f * SustainLevel - 1.361f) / StepsLeft;
230	schoenebeck	738	Coeff = Decay1Slope * invVolume;
231	persson	614	Decay1Level2 = 0.25 * invVolume;
232	persson	1147	StepsLeft = int((RTMath::Max(Decay1Level2, SustainLevel) - Level) / Coeff);
233			if (StepsLeft <= 0) enterDecay1Part2Stage(SampleRate);
234	schoenebeck	738	} else {
235			if (InfiniteSustain) enterSustainStage();
236			else enterDecay2Stage(SampleRate);
237	persson	614	}
238	schoenebeck	738	}
239	schoenebeck	53
240	persson	768	void EGADSR::enterDecay1Part2Stage(const uint SampleRate) {
241			if (SustainLevel < Decay1Level2) {
242			Stage = stage_decay1_part2;
243			Segment = segment_exp;
244			Decay1Slope *= 3.55;
245			Coeff = exp(Decay1Slope);
246			Offset = ExpOffset * (1 - Coeff);
247			StepsLeft = int(log((SustainLevel - ExpOffset) / (Level - ExpOffset)) / Decay1Slope);
248	persson	1147	if (StepsLeft > 0) return;
249	persson	768	}
250	persson	1147	if (InfiniteSustain) enterSustainStage();
251			else enterDecay2Stage(SampleRate);
252	schoenebeck	738	}
253	schoenebeck	53
254	schoenebeck	738	void EGADSR::enterDecay2Stage(const uint SampleRate) {
255			Stage = stage_decay2;
256			Segment = segment_lin;
257	persson	1046	Decay2Time = RTMath::Max(Decay2Time, 0.05f);
258	schoenebeck	738	StepsLeft = (int) (Decay2Time * SampleRate);
259			Coeff = (-1.03 / StepsLeft) * invVolume;
260			//FIXME: do we really have to calculate 'StepsLeft' two times?
261			StepsLeft = int((CONFIG_EG_BOTTOM - Level) / Coeff);
262	persson	1147	if (StepsLeft <= 0) enterEndStage();
263	schoenebeck	738	}
264	schoenebeck	53
265	schoenebeck	738	void EGADSR::enterSustainStage() {
266			Stage = stage_sustain;
267			Segment = segment_lin;
268			Coeff = 0.0f; // don't change the envelope level in this stage
269			const int intMax = (unsigned int) -1 >> 1;
270			StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
271	schoenebeck	53	}
272
273	schoenebeck	738	void EGADSR::enterReleasePart1Stage() {
274			Stage = stage_release_part1;
275			Segment = segment_lin;
276			StepsLeft = int((ReleaseLevel2 - Level) / ReleaseCoeff);
277			Coeff = ReleaseCoeff;
278	persson	1147	if (StepsLeft <= 0) enterReleasePart2Stage();
279	schoenebeck	738	}
280
281			void EGADSR::enterReleasePart2Stage() {
282			Stage = stage_release_part2;
283			Segment = segment_exp;
284			StepsLeft = int(log((CONFIG_EG_BOTTOM - ExpOffset) / (Level - ExpOffset)) / ReleaseSlope);
285			Coeff = ReleaseCoeff2;
286			Offset = ReleaseCoeff3;
287	persson	1147	if (StepsLeft <= 0) enterFadeOutStage();
288	schoenebeck	738	}
289
290			void EGADSR::enterFadeOutStage() {
291			Stage = stage_fadeout;
292			Segment = segment_lin;
293			StepsLeft = int(Level / (-FadeOutCoeff));
294			Coeff = FadeOutCoeff;
295	persson	1147	if (StepsLeft <= 0) enterEndStage();
296	schoenebeck	738	}
297
298	persson	1748	void EGADSR::enterFadeOutStage(int maxFadeOutSteps) {
299			Stage = stage_fadeout;
300			Segment = segment_lin;
301			StepsLeft = int(Level / (-FadeOutCoeff));
302			if (StepsLeft > maxFadeOutSteps) {
303			StepsLeft = maxFadeOutSteps;
304			Coeff = -Level / maxFadeOutSteps;
305			} else {
306			Coeff = FadeOutCoeff;
307			}
308			if (StepsLeft <= 0) enterEndStage();
309			}
310
311	schoenebeck	738	void EGADSR::enterEndStage() {
312			Stage = stage_end;
313			Segment = segment_end;
314	persson	830	Level = 0;
315	schoenebeck	738	}
316
317	schoenebeck	53	}} // namespace LinuxSampler::gig