engines/sfz/EGADSR.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2011 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., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#include "EGADSR.h"

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

namespace LinuxSampler { namespace sfz {

    // Modeled after output from SFZ Player 1.97 / Rapture Demo 1.0.

    void EGADSR::update(event_t Event, uint SampleRate) {
        if (atEnd(Event)) return;

        switch (Stage) {
            case stage_attack:
                switch (Event) {
                    case event_release:
                        enterReleaseStage();
                        break;
                    case event_stage_end:
                        if (HoldSteps)
                            enterAttackHoldStage();
                        else
                            enterDecayStage(SampleRate);
                        break;
                }
                break;
            case stage_attack_hold:
                switch (Event) {
                    case event_stage_end:
                        enterDecayStage(SampleRate);
                        break;
                    case event_release:
                        enterReleaseStage();
                        break;
                }
                break;
            case stage_decay:
                switch (Event) {
                    case event_release:
                        enterReleaseStage();
                        break;
                    case event_stage_end:
                        if (Level < CONFIG_EG_BOTTOM)
                            enterEndStage();
                        else
                            enterSustainStage();
                        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:
                        enterReleaseStage();
                        break;
                }
                break;
            case stage_release:
                switch (Event) {
                    case event_stage_end:
                        enterFadeOutStage();
                        break;
                    case event_cancel_release:
                        enterSustainStage();
                        break;
                }
                break;
        }
    }

    void EGADSR::trigger(uint PreAttack, float AttackTime, float HoldTime, float DecayTime, uint SustainLevel, float ReleaseTime, uint SampleRate) {
        this->SustainLevel = SustainLevel / 1000.0;
        this->HoldSteps    = int(HoldTime * SampleRate);
        this->DecayTime    = DecayTime;

        if (ReleaseTime < CONFIG_EG_MIN_RELEASE_TIME) ReleaseTime = CONFIG_EG_MIN_RELEASE_TIME;  // to avoid click sounds at the end of the sample playback
        ReleaseSlope = -9.226 / (ReleaseTime * SampleRate);
        Offset = 0;
        enterFirstStage();
        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) {
            StepsLeft = int(AttackTime * SampleRate);
            Level = (float) PreAttack / 1000.0;
            Coeff = (1.0f - Level) / StepsLeft;
        } else { // attack is zero - immediately jump to the next stage
            Level = 1.0f;
            if (HoldSteps) enterAttackHoldStage();
            else           enterDecayStage(SampleRate);
        }
    }

    void EGADSR::enterAttackHoldStage() {
        Stage     = stage_attack_hold;
        Segment   = segment_lin;
        Coeff     = 0.0f; // don't rise anymore
        StepsLeft = HoldSteps;
    }

    void EGADSR::enterDecayStage(const uint SampleRate) {
        StepsLeft = (int) (DecayTime * SampleRate);
        if (StepsLeft && Level > SustainLevel) {
            Stage   = stage_decay;
            Segment = segment_exp;
            const float slope = -9.226 / StepsLeft;
            Coeff  = exp(slope);
            StepsLeft = int(log(std::max(SustainLevel, float(CONFIG_EG_BOTTOM)) / Level) / slope);
            if (StepsLeft > 0) return;
        }
        Level = SustainLevel;
        enterSustainStage();
    }

    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::enterReleaseStage() {
        Stage     = stage_release;
        Segment   = segment_exp;
        StepsLeft = int(log(CONFIG_EG_BOTTOM / Level) / ReleaseSlope);
        Coeff     = exp(ReleaseSlope);
        if (StepsLeft <= 0) enterFadeOutStage();
    }

}} // namespace LinuxSampler::sfz
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005 - 2011 Christian Schoenebeck *
7	* *
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., 51 Franklin St, Fifth Floor, Boston, *
21	* MA 02110-1301 USA *
22	***************************************************************************/
23
24	#include "EGADSR.h"
25
26	#include "../../common/global_private.h"
27
28	namespace LinuxSampler { namespace sfz {
29
30	// Modeled after output from SFZ Player 1.97 / Rapture Demo 1.0.
31
32	void EGADSR::update(event_t Event, uint SampleRate) {
33	if (atEnd(Event)) return;
34
35	switch (Stage) {
36	case stage_attack:
37	switch (Event) {
38	case event_release:
39	enterReleaseStage();
40	break;
41	case event_stage_end:
42	if (HoldSteps)
43	enterAttackHoldStage();
44	else
45	enterDecayStage(SampleRate);
46	break;
47	}
48	break;
49	case stage_attack_hold:
50	switch (Event) {
51	case event_stage_end:
52	enterDecayStage(SampleRate);
53	break;
54	case event_release:
55	enterReleaseStage();
56	break;
57	}
58	break;
59	case stage_decay:
60	switch (Event) {
61	case event_release:
62	enterReleaseStage();
63	break;
64	case event_stage_end:
65	if (Level < CONFIG_EG_BOTTOM)
66	enterEndStage();
67	else
68	enterSustainStage();
69	break;
70	}
71	break;
72	case stage_sustain:
73	switch (Event) {
74	case event_stage_end: { // just refresh time
75	const int intMax = (unsigned int) -1 >> 1;
76	StepsLeft = intMax; // we use the highest possible value
77	break;
78	}
79	case event_release:
80	enterReleaseStage();
81	break;
82	}
83	break;
84	case stage_release:
85	switch (Event) {
86	case event_stage_end:
87	enterFadeOutStage();
88	break;
89	case event_cancel_release:
90	enterSustainStage();
91	break;
92	}
93	break;
94	}
95	}
96
97	void EGADSR::trigger(uint PreAttack, float AttackTime, float HoldTime, float DecayTime, uint SustainLevel, float ReleaseTime, uint SampleRate) {
98	this->SustainLevel = SustainLevel / 1000.0;
99	this->HoldSteps = int(HoldTime * SampleRate);
100	this->DecayTime = DecayTime;
101
102	if (ReleaseTime < CONFIG_EG_MIN_RELEASE_TIME) ReleaseTime = CONFIG_EG_MIN_RELEASE_TIME; // to avoid click sounds at the end of the sample playback
103	ReleaseSlope = -9.226 / (ReleaseTime * SampleRate);
104	Offset = 0;
105	enterFirstStage();
106	enterAttackStage(PreAttack, AttackTime, SampleRate);
107	}
108
109	void EGADSR::enterAttackStage(const uint PreAttack, const float AttackTime, const uint SampleRate) {
110	Stage = stage_attack;
111	Segment = segment_lin;
112
113	if (AttackTime >= 0.0005f) {
114	StepsLeft = int(AttackTime * SampleRate);
115	Level = (float) PreAttack / 1000.0;
116	Coeff = (1.0f - Level) / StepsLeft;
117	} else { // attack is zero - immediately jump to the next stage
118	Level = 1.0f;
119	if (HoldSteps) enterAttackHoldStage();
120	else enterDecayStage(SampleRate);
121	}
122	}
123
124	void EGADSR::enterAttackHoldStage() {
125	Stage = stage_attack_hold;
126	Segment = segment_lin;
127	Coeff = 0.0f; // don't rise anymore
128	StepsLeft = HoldSteps;
129	}
130
131	void EGADSR::enterDecayStage(const uint SampleRate) {
132	StepsLeft = (int) (DecayTime * SampleRate);
133	if (StepsLeft && Level > SustainLevel) {
134	Stage = stage_decay;
135	Segment = segment_exp;
136	const float slope = -9.226 / StepsLeft;
137	Coeff = exp(slope);
138	StepsLeft = int(log(std::max(SustainLevel, float(CONFIG_EG_BOTTOM)) / Level) / slope);
139	if (StepsLeft > 0) return;
140	}
141	Level = SustainLevel;
142	enterSustainStage();
143	}
144
145	void EGADSR::enterSustainStage() {
146	Stage = stage_sustain;
147	Segment = segment_lin;
148	Coeff = 0.0f; // don't change the envelope level in this stage
149	const int intMax = (unsigned int) -1 >> 1;
150	StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
151	}
152
153	void EGADSR::enterReleaseStage() {
154	Stage = stage_release;
155	Segment = segment_exp;
156	StepsLeft = int(log(CONFIG_EG_BOTTOM / Level) / ReleaseSlope);
157	Coeff = exp(ReleaseSlope);
158	if (StepsLeft <= 0) enterFadeOutStage();
159	}
160
161	}} // namespace LinuxSampler::sfz