engines/common/EG.h

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

#ifndef LS_EG_H
#define LS_EG_H

#include <cmath>
#include "../../common/RTMath.h"

namespace LinuxSampler {
    class EG {
    public:

        /**
         * Used to define what kind of segment the envelope currently is at.
         */
        enum segment_t {
            segment_end = 0, ///< final end state of envelope reached
            segment_lin = 1, ///< envelope is currently at a linear segment
            segment_exp = 2, ///< envelope is currently at a exponential segment
            segment_pow = 3  ///< envelope is currently at a power segment
        };

        /**
         * Used to inform the EG about an event.
         */
        enum event_t {
            event_stage_end,
            event_release,
            event_cancel_release,
            event_hold_end
        };

        /**
         * Change fade out time.
         */
        void CalculateFadeOutCoeff(float FadeOutTime, float SampleRate);

        /**
         * Returns true in case envelope hasn't reached its final end state yet.
         */
        bool active() {
            return Segment;
        }

        /**
         * Returns what kind of segment the envelope currently is at.
         */
        segment_t getSegmentType() {
            return Segment;
        }

        /**
         * Advance envelope by \a SamplePoints steps.
         */
        void increment(int SamplePoints) {
            StepsLeft = RTMath::Max(0, StepsLeft - SamplePoints);
        }

        /**
         * Returns amount of steps until the end of current envelope stage.
         */
        int toStageEndLeft() {
            return StepsLeft;
        }

        /**
         * Should be called to inform the EG about an external event and
         * also whenever an envelope stage is completed. This will handle
         * the envelope's transition to the respective next stage.
         *
         * @param Event        - what happened
         */
        virtual void update(event_t Event, uint SampleRate) = 0;

        /**
         * Calculates exactly one, the next sample point of EG
         * (linear segment). Call this if envelope is currently in a linear
         * segment.
         *
         * @returns next envelope level
         */
        float processLin() {
            return (Level += Coeff);
        }

        /**
         * Calculates exactly one, the next sample point of EG
         * (exponential segment). Call this if envelope is currently in an
         * exponential segment.
         *
         * @returns next envelope level
         */
        float processExp() {
            return (Level = Level * Coeff + Offset);
        }

        /**
         * Calculates exactly one, the next sample point of EG (power
         * segment). Call this if envelope is currently in an power
         * segment.
         *
         * @returns next envelope level
         */
        float processPow() {
            // TODO: this could be optimised by a pow approximation
            Level = Offset + Coeff * powf(X, Exp);
            X += XDelta;
            return Level;
        }

        /**
         * Returns current envelope level without modifying anything. This
         * might be needed once the envelope reached its final end state,
         * because calling processLin() or processExp() at this point will
         * result in undesired behavior.
         */
        float getLevel() {
            return Level;
        }

        void enterFadeOutStage();
        void enterFadeOutStage(int maxFadeOutSteps);

    protected:
        float     Level;
        float     Coeff;
        float     Offset;
        float     Exp;
        float     X;
        float     XDelta;
        int       StepsLeft;
        segment_t Segment;

        EG();
        void enterFirstStage() { // must be called in trigger
            Stage = stage_main;
        }
        bool atEnd(event_t Event); // must be called first in update
        void enterEndStage();

    private:
        enum stage_t {
            stage_main,
            stage_fadeout,
            stage_end
        };

        stage_t   Stage;
        float     FadeOutCoeff; ///< very fast ramp down for e.g. voice stealing
};
}

#endif
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005 - 2010 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	#ifndef LS_EG_H
25	#define LS_EG_H
26
27	#include <cmath>
28	#include "../../common/RTMath.h"
29
30	namespace LinuxSampler {
31	class EG {
32	public:
33
34	/**
35	* Used to define what kind of segment the envelope currently is at.
36	*/
37	enum segment_t {
38	segment_end = 0, ///< final end state of envelope reached
39	segment_lin = 1, ///< envelope is currently at a linear segment
40	segment_exp = 2, ///< envelope is currently at a exponential segment
41	segment_pow = 3 ///< envelope is currently at a power segment
42	};
43
44	/**
45	* Used to inform the EG about an event.
46	*/
47	enum event_t {
48	event_stage_end,
49	event_release,
50	event_cancel_release,
51	event_hold_end
52	};
53
54	/**
55	* Change fade out time.
56	*/
57	void CalculateFadeOutCoeff(float FadeOutTime, float SampleRate);
58
59	/**
60	* Returns true in case envelope hasn't reached its final end state yet.
61	*/
62	bool active() {
63	return Segment;
64	}
65
66	/**
67	* Returns what kind of segment the envelope currently is at.
68	*/
69	segment_t getSegmentType() {
70	return Segment;
71	}
72
73	/**
74	* Advance envelope by \a SamplePoints steps.
75	*/
76	void increment(int SamplePoints) {
77	StepsLeft = RTMath::Max(0, StepsLeft - SamplePoints);
78	}
79
80	/**
81	* Returns amount of steps until the end of current envelope stage.
82	*/
83	int toStageEndLeft() {
84	return StepsLeft;
85	}
86
87	/**
88	* Should be called to inform the EG about an external event and
89	* also whenever an envelope stage is completed. This will handle
90	* the envelope's transition to the respective next stage.
91	*
92	* @param Event - what happened
93	*/
94	virtual void update(event_t Event, uint SampleRate) = 0;
95
96	/**
97	* Calculates exactly one, the next sample point of EG
98	* (linear segment). Call this if envelope is currently in a linear
99	* segment.
100	*
101	* @returns next envelope level
102	*/
103	float processLin() {
104	return (Level += Coeff);
105	}
106
107	/**
108	* Calculates exactly one, the next sample point of EG
109	* (exponential segment). Call this if envelope is currently in an
110	* exponential segment.
111	*
112	* @returns next envelope level
113	*/
114	float processExp() {
115	return (Level = Level * Coeff + Offset);
116	}
117
118	/**
119	* Calculates exactly one, the next sample point of EG (power
120	* segment). Call this if envelope is currently in an power
121	* segment.
122	*
123	* @returns next envelope level
124	*/
125	float processPow() {
126	// TODO: this could be optimised by a pow approximation
127	Level = Offset + Coeff * powf(X, Exp);
128	X += XDelta;
129	return Level;
130	}
131
132	/**
133	* Returns current envelope level without modifying anything. This
134	* might be needed once the envelope reached its final end state,
135	* because calling processLin() or processExp() at this point will
136	* result in undesired behavior.
137	*/
138	float getLevel() {
139	return Level;
140	}
141
142	void enterFadeOutStage();
143	void enterFadeOutStage(int maxFadeOutSteps);
144
145	protected:
146	float Level;
147	float Coeff;
148	float Offset;
149	float Exp;
150	float X;
151	float XDelta;
152	int StepsLeft;
153	segment_t Segment;
154
155	EG();
156	void enterFirstStage() { // must be called in trigger
157	Stage = stage_main;
158	}
159	bool atEnd(event_t Event); // must be called first in update
160	void enterEndStage();
161
162	private:
163	enum stage_t {
164	stage_main,
165	stage_fadeout,
166	stage_end
167	};
168
169	stage_t Stage;
170	float FadeOutCoeff; ///< very fast ramp down for e.g. voice stealing
171	};
172	}
173
174	#endif