engines/gig/SmoothVolume.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2006 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 <cmath>
#include "SmoothVolume.h"

#include <cstdio>

namespace LinuxSampler { namespace gig {

    void SmoothVolume::trigger(float volume, float sampleRate) {
        float d = 1 / sampleRate;
        a1 = exp(-44 * d);
        b0 = 1 - a1;
        decay = exp(-11 * d);
        coeff = 0.33f * d;
        this->volume = volume;
        moving = false;
    }

    float SmoothVolume::process() {
        if (goal < volume) {
            // decreasing
            float newVolume = volume > 0.059f ? volume * decay : volume - coeff;
            if (newVolume > goal) volume = newVolume;
            else {
                volume = goal;
                moving = false;
            }
        } else {
            // increasing
            if (goal - volume > 0.013f)
                volume = b0 * goal + a1 * volume; // one-pole LP filter
            else {
                float newVolume = volume + coeff;
                if (newVolume < goal) volume = newVolume;
                else {
                    volume = goal;
                    moving = false;
                }
            }
        }
        return volume;
    }

}};
1	persson	832	/***************************************************************************
2			* *
3			* Copyright (C) 2006 Andreas Persson *
4			* *
5			* This program is free software; you can redistribute it and/or modify *
6			* it under the terms of the GNU General Public License as published by *
7			* the Free Software Foundation; either version 2 of the License, or *
8			* (at your option) any later version. *
9			* *
10			* This program is distributed in the hope that it will be useful, *
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13			* GNU General Public License for more details. *
14			* *
15			* You should have received a copy of the GNU General Public License *
16			* along with this program; if not, write to the Free Software *
17			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
18			* MA 02110-1301 USA *
19			***************************************************************************/
20
21			#include <cmath>
22			#include "SmoothVolume.h"
23
24			#include <cstdio>
25
26			namespace LinuxSampler { namespace gig {
27
28			void SmoothVolume::trigger(float volume, float sampleRate) {
29			float d = 1 / sampleRate;
30			a1 = exp(-44 * d);
31			b0 = 1 - a1;
32			decay = exp(-11 * d);
33			coeff = 0.33f * d;
34			this->volume = volume;
35			moving = false;
36			}
37
38			float SmoothVolume::process() {
39			if (goal < volume) {
40			// decreasing
41			float newVolume = volume > 0.059f ? volume * decay : volume - coeff;
42			if (newVolume > goal) volume = newVolume;
43			else {
44			volume = goal;
45			moving = false;
46			}
47			} else {
48			// increasing
49			if (goal - volume > 0.013f)
50			volume = b0 * goal + a1 * volume; // one-pole LP filter
51			else {
52			float newVolume = volume + coeff;
53			if (newVolume < goal) volume = newVolume;
54			else {
55			volume = goal;
56			moving = false;
57			}
58			}
59			}
60			return volume;
61			}
62
63			}};