/[svn]/linuxsampler/trunk/src/engines/sfz/EGADSR.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/sfz/EGADSR.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2311 - (show annotations) (download)
Sat Feb 11 11:08:09 2012 UTC (12 years, 1 month ago) by persson
File size: 7380 byte(s)
* more LV2 "state" extension support fixes (patch by David Robillard)
* sfz parser: allow double spaces in sample filenames
* sfz parser: allow absolute paths for sample filenames
* MME driver: fixed memory handling bug found with cppcheck
* sfz/sf2 engines: use linear decay and release for filter and pitch
  envelope generators

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2012 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, bool LinearRelease) {
98 this->SustainLevel = SustainLevel / 1000.0;
99 this->HoldSteps = int(HoldTime * SampleRate);
100 this->DecayTime = DecayTime;
101 this->LinearRelease = LinearRelease;
102
103 if (ReleaseTime < CONFIG_EG_MIN_RELEASE_TIME) ReleaseTime = CONFIG_EG_MIN_RELEASE_TIME; // to avoid click sounds at the end of the sample playback
104 this->ReleaseTime = ReleaseTime * SampleRate;
105 Offset = 0;
106 enterFirstStage();
107 enterAttackStage(PreAttack, AttackTime, SampleRate);
108 }
109
110 void EGADSR::enterAttackStage(const uint PreAttack, const float AttackTime, const uint SampleRate) {
111 Stage = stage_attack;
112 Segment = segment_lin;
113
114 if (AttackTime >= 0.0005f) {
115 StepsLeft = int(AttackTime * SampleRate);
116 Level = (float) PreAttack / 1000.0;
117 Coeff = (1.0f - Level) / StepsLeft;
118 } else { // attack is zero - immediately jump to the next stage
119 Level = 1.0f;
120 if (HoldSteps) enterAttackHoldStage();
121 else enterDecayStage(SampleRate);
122 }
123 }
124
125 void EGADSR::enterAttackHoldStage() {
126 Stage = stage_attack_hold;
127 Segment = segment_lin;
128 Coeff = 0.0f; // don't rise anymore
129 StepsLeft = HoldSteps;
130 }
131
132 void EGADSR::enterDecayStage(const uint SampleRate) {
133 if (LinearRelease) {
134 StepsLeft = int(DecayTime * SampleRate * (Level - SustainLevel));
135 if (StepsLeft > 0) {
136 Stage = stage_decay;
137 Segment = segment_lin;
138 Coeff = -1 / (DecayTime * SampleRate);
139 return;
140 }
141 } else {
142 StepsLeft = int(DecayTime * SampleRate);
143 if (StepsLeft && Level > SustainLevel) {
144 Stage = stage_decay;
145 Segment = segment_exp;
146 const float slope = -9.226 / StepsLeft;
147 Coeff = exp(slope);
148 StepsLeft = int(log(std::max(SustainLevel, float(CONFIG_EG_BOTTOM)) / Level) / slope);
149 if (StepsLeft > 0) return;
150 }
151 }
152 Level = SustainLevel;
153 enterSustainStage();
154 }
155
156 void EGADSR::enterSustainStage() {
157 Stage = stage_sustain;
158 Segment = segment_lin;
159 Coeff = 0.0f; // don't change the envelope level in this stage
160 const int intMax = (unsigned int) -1 >> 1;
161 StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
162 }
163
164 void EGADSR::enterReleaseStage() {
165 Stage = stage_release;
166 if (LinearRelease) {
167 Segment = segment_lin;
168 StepsLeft = int(Level * ReleaseTime);
169 Coeff = -1 / ReleaseTime;
170 } else {
171 Segment = segment_exp;
172 const float slope = -9.226 / ReleaseTime;
173 StepsLeft = int(log(CONFIG_EG_BOTTOM / Level) / slope);
174 Coeff = exp(slope);
175 }
176 if (StepsLeft <= 0) enterFadeOutStage();
177 }
178
179 }} // namespace LinuxSampler::sfz

  ViewVC Help
Powered by ViewVC