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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1906 - (show annotations) (download)
Sat May 16 12:14:27 2009 UTC (14 years, 10 months ago) by persson
File size: 13220 byte(s)
* bugfix: sometimes, when playing a note twice fast, the second note
  was silent

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2009 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., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #include "EGADSR.h"
25
26 #include "../../common/global_private.h"
27
28 namespace LinuxSampler { namespace gig {
29
30 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 void EGADSR::CalculateFadeOutCoeff(float FadeOutTime, float SampleRate) {
37 const float killSteps = FadeOutTime * SampleRate / CONFIG_DEFAULT_SUBFRAGMENT_SIZE;
38 FadeOutCoeff = -1.0f / killSteps;
39 }
40
41 void EGADSR::update(event_t Event, uint SampleRate) {
42 if (Event == event_hold_end) HoldAttack = false;
43
44 switch (Stage) {
45 case stage_attack:
46 switch (Event) {
47 case event_release:
48 enterReleasePart1Stage();
49 break;
50 case event_stage_end:
51 if (HoldAttack)
52 enterAttackHoldStage();
53 else
54 enterDecay1Part1Stage(SampleRate);
55 break;
56 }
57 break;
58 case stage_attack_hold:
59 switch (Event) {
60 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 enterDecay1Part1Stage(SampleRate);
67 break;
68 case event_release:
69 enterReleasePart1Stage();
70 break;
71 }
72 break;
73 case stage_decay1_part1:
74 switch (Event) {
75 case event_stage_end:
76 enterDecay1Part2Stage(SampleRate);
77 break;
78 case event_cancel_release:
79 if (InfiniteSustain)
80 enterSustainStage();
81 else
82 enterDecay2Stage(SampleRate);
83 break;
84 }
85 break;
86 case stage_decay1_part2:
87 switch (Event) {
88 case event_release:
89 enterReleasePart1Stage();
90 break;
91 case event_stage_end:
92 if (Level < CONFIG_EG_BOTTOM)
93 enterEndStage();
94 else if (InfiniteSustain)
95 enterSustainStage();
96 else
97 enterDecay2Stage(SampleRate);
98 break;
99 }
100 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 case event_hold_end:
110 enterDecay1Part1Stage(SampleRate);
111 break;
112 }
113 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 }
121 case event_release:
122 enterReleasePart1Stage();
123 break;
124 case event_hold_end:
125 enterDecay1Part1Stage(SampleRate);
126 break;
127 }
128 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 }
141 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 }
154 break;
155 case stage_fadeout:
156 switch (Event) {
157 case event_stage_end:
158 enterEndStage();
159 break;
160 }
161 break;
162 }
163 }
164
165 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 this->InfiniteSustain = InfiniteSustain;
168 this->HoldAttack = HoldAttack;
169
170 this->Decay1Time = Decay1Time;
171 this->Decay2Time = Decay2Time;
172
173 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
186 enterAttackStage(PreAttack, AttackTime, SampleRate);
187 }
188
189 void EGADSR::enterAttackStage(const uint PreAttack, const float AttackTime, const uint SampleRate) {
190 Stage = stage_attack;
191 Segment = segment_lin;
192
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 Level = (float) PreAttack / 1000.0;
199 Coeff = 0.896f * (1.0f - Level) / StepsLeft; // max level is a bit lower if attack != 0
200 } else { // attack is zero - immediately jump to the next stage
201 Level = 1.029f; // a bit higher than max sustain
202 if (HoldAttack) enterAttackHoldStage();
203 else enterDecay1Part1Stage(SampleRate);
204 }
205 }
206
207 void EGADSR::enterAttackHoldStage() {
208 Stage = stage_attack_hold;
209 Segment = segment_lin;
210 Coeff = 0.0f; // don't rise anymore
211 const int intMax = (unsigned int) -1 >> 1;
212 StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
213 }
214
215 void EGADSR::enterDecay1Part1Stage(const uint SampleRate) {
216 // 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 StepsLeft = (int) (Decay1Time * SampleRate);
226 if (StepsLeft && Level > SustainLevel) {
227 Stage = stage_decay1_part1;
228 Segment = segment_lin;
229 Decay1Slope = (1.347f * SustainLevel - 1.361f) / StepsLeft;
230 Coeff = Decay1Slope * invVolume;
231 Decay1Level2 = 0.25 * invVolume;
232 StepsLeft = int((RTMath::Max(Decay1Level2, SustainLevel) - Level) / Coeff);
233 if (StepsLeft <= 0) enterDecay1Part2Stage(SampleRate);
234 } else {
235 if (InfiniteSustain) enterSustainStage();
236 else enterDecay2Stage(SampleRate);
237 }
238 }
239
240 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 if (StepsLeft > 0) return;
249 }
250 if (InfiniteSustain) enterSustainStage();
251 else enterDecay2Stage(SampleRate);
252 }
253
254 void EGADSR::enterDecay2Stage(const uint SampleRate) {
255 Stage = stage_decay2;
256 Segment = segment_lin;
257 Decay2Time = RTMath::Max(Decay2Time, 0.05f);
258 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 if (StepsLeft <= 0) enterEndStage();
263 }
264
265 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 }
272
273 void EGADSR::enterReleasePart1Stage() {
274 Stage = stage_release_part1;
275 Segment = segment_lin;
276 StepsLeft = int((ReleaseLevel2 - Level) / ReleaseCoeff);
277 Coeff = ReleaseCoeff;
278 if (StepsLeft <= 0) enterReleasePart2Stage();
279 }
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 if (StepsLeft <= 0) enterFadeOutStage();
288 }
289
290 void EGADSR::enterFadeOutStage() {
291 Stage = stage_fadeout;
292 Segment = segment_lin;
293 StepsLeft = int(Level / (-FadeOutCoeff));
294 Coeff = FadeOutCoeff;
295 if (StepsLeft <= 0) enterEndStage();
296 }
297
298 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 void EGADSR::enterEndStage() {
312 Stage = stage_end;
313 Segment = segment_end;
314 Level = 0;
315 }
316
317 }} // namespace LinuxSampler::gig

  ViewVC Help
Powered by ViewVC