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

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

        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)

        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	/***************************************************************************
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
38	void EG::update(event_t Event, uint SampleRate) {
39	if (atEnd(Event)) return;
40
41	if (Event == event_stage_end \|\| Event == event_release) {
42	if (Stage == eg->node.size() - 1) {
43	enterFadeOutStage();
44	} else if (Stage == eg->sustain && Stage != 0 &&
45	Event != event_release) {
46	enterSustainStage();
47	} else {
48	if (Event == event_release) {
49	Stage = eg->sustain;
50	} else {
51	Level = eg->node[Stage].level;
52	}
53
54	Stage++;
55
56	float shape = eg->node[Stage].shape;
57	if (shape < 0.000001) shape = 1;
58
59	float xd = eg->node[Stage].time * SampleRate * TimeCoeff;
60	float yd = eg->node[Stage].level - Level;
61
62	if (eg->node[Stage - 1].shape > 0.999999 \|\|
63	eg->node[Stage - 1].shape < 0.000001) {
64	Exp = 1 / shape;
65	Offset = Level;
66	X = 0;
67	XDelta = 1 / xd;
68	Coeff = yd;
69	} else {
70	Exp = shape;
71	Offset = eg->node[Stage].level;
72	X = 1;
73	XDelta = -1 / xd;
74	Coeff = -yd;
75	}
76	Segment = segment_pow;
77	StepsLeft = int(xd);
78	}
79	}
80	}
81
82	void EG::trigger(::sfz::EG& eg, uint SampleRate, uint8_t Velocity) {
83	Stage = 0;
84	this->eg = &eg;
85	TimeCoeff = exp(0.0054578518 * Velocity); // pow(2, Velcocity / 127)
86
87	enterFirstStage();
88	update(event_stage_end, SampleRate);
89	}
90
91	void EG::enterSustainStage() {
92	Segment = segment_lin;
93	Coeff = 0.0f; // don't change the envelope level in this stage
94	const int intMax = (unsigned int) -1 >> 1;
95	StepsLeft = intMax; // we use the highest value possible (we refresh StepsLeft in update() in case)
96	Level = eg->node[Stage].level;
97	}
98	}} // namespace LinuxSampler::sfz