engines/sfz/EG.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2010 Andreas Persson                                    *
 *                                                                         *
 *   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 "EG.h"

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

namespace LinuxSampler { namespace sfz {

    // Modeled after output from Rapture Demo 1.0, which means the
    // stages are using a pow function and the "curve" parameter of
    // the stage is ignored. The "shape" parameter decides the slope
    // of the stage, a value of 1.0 or 0.0 means linear shape. The
    // length of the stages are dependent on the velocity.

    // TODO: add support for loops
    // TODO: optimization: use segment_lin for linear stages
    // TODO: support cancel_release events?

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

        // ignore duplicated release events
        if (Event == event_release) {
            if (GotRelease) return;
            GotRelease = true;
        }

        if (Event == event_stage_end || Event == event_release) {
            if (Stage == eg->node.size() - 1) {
                enterFadeOutStage();
            } else if (Stage == eg->sustain && Stage != 0 &&
                       Event != event_release) {
                enterSustainStage();
            } else {
                if (Event == event_release) {
                    Stage = eg->sustain;
                } else {
                    Level = eg->node[Stage].level;
                }

                Stage++;

                float shape = eg->node[Stage].shape;
                if (shape < 0.000001) shape = 1;

                float xd = eg->node[Stage].time * SampleRate * TimeCoeff;
                float yd = eg->node[Stage].level - Level;

                if (eg->node[Stage - 1].shape > 0.999999 ||
                    eg->node[Stage - 1].shape < 0.000001) {
                    Exp = 1 / shape;
                    Offset = Level;
                    X = 0;
                    XDelta = 1 / xd;
                    Coeff = yd;
                } else {
                    Exp = shape;
                    Offset = eg->node[Stage].level;
                    X = 1;
                    XDelta = -1 / xd;
                    Coeff = -yd;
                }
                Segment = segment_pow;
                StepsLeft = int(xd);
            }
        }
    }

    void EG::trigger(::sfz::EG& eg, uint SampleRate, uint8_t Velocity) {
        Stage = 0;
        this->eg = &eg;
        TimeCoeff = exp(0.0054578518 * Velocity); // pow(2, Velcocity / 127)
        GotRelease = false;

        enterFirstStage();
        update(event_stage_end, SampleRate);
    }

    void EG::enterSustainStage() {
        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)
        Level = eg->node[Stage].level;
    }
}} // namespace LinuxSampler::sfz
1	persson	2055	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2010 Andreas Persson *
6			* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
20			* MA 02110-1301 USA *
21			***************************************************************************/
22
23			#include "EG.h"
24
25			#include "../../common/global_private.h"
26
27			namespace LinuxSampler { namespace sfz {
28
29			// Modeled after output from Rapture Demo 1.0, which means the
30			// stages are using a pow function and the "curve" parameter of
31			// the stage is ignored. The "shape" parameter decides the slope
32			// of the stage, a value of 1.0 or 0.0 means linear shape. The
33			// length of the stages are dependent on the velocity.
34
35			// TODO: add support for loops
36			// TODO: optimization: use segment_lin for linear stages
37	persson	2114	// TODO: support cancel_release events?
38	persson	2055
39			void EG::update(event_t Event, uint SampleRate) {
40			if (atEnd(Event)) return;
41
42	persson	2114	// ignore duplicated release events
43			if (Event == event_release) {
44			if (GotRelease) return;
45			GotRelease = true;
46			}
47
48	persson	2055	if (Event == event_stage_end \|\| Event == event_release) {
49			if (Stage == eg->node.size() - 1) {
50			enterFadeOutStage();
51			} else if (Stage == eg->sustain && Stage != 0 &&
52			Event != event_release) {
53			enterSustainStage();
54			} else {
55			if (Event == event_release) {
56			Stage = eg->sustain;
57			} else {
58			Level = eg->node[Stage].level;
59			}
60
61			Stage++;
62
63			float shape = eg->node[Stage].shape;
64			if (shape < 0.000001) shape = 1;
65
66			float xd = eg->node[Stage].time * SampleRate * TimeCoeff;
67			float yd = eg->node[Stage].level - Level;
68
69			if (eg->node[Stage - 1].shape > 0.999999 \|\|
70			eg->node[Stage - 1].shape < 0.000001) {
71			Exp = 1 / shape;
72			Offset = Level;
73			X = 0;
74			XDelta = 1 / xd;
75			Coeff = yd;
76			} else {
77			Exp = shape;
78			Offset = eg->node[Stage].level;
79			X = 1;
80			XDelta = -1 / xd;
81			Coeff = -yd;
82			}
83			Segment = segment_pow;
84			StepsLeft = int(xd);
85			}
86			}
87			}
88
89			void EG::trigger(::sfz::EG& eg, uint SampleRate, uint8_t Velocity) {
90			Stage = 0;
91			this->eg = &eg;
92			TimeCoeff = exp(0.0054578518 * Velocity); // pow(2, Velcocity / 127)
93	persson	2114	GotRelease = false;
94	persson	2055
95			enterFirstStage();
96			update(event_stage_end, SampleRate);
97			}
98
99			void EG::enterSustainStage() {
100			Segment = segment_lin;
101			Coeff = 0.0f; // don't change the envelope level in this stage
102			const int intMax = (unsigned int) -1 >> 1;
103			StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
104			Level = eg->node[Stage].level;
105			}
106			}} // namespace LinuxSampler::sfz