v0_1_0/src/lfo.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003 by Benno Senoner and 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., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LFO_H__
#define __LFO_H__

#include "global.h"
#include "rtelmemorypool.h"
#include "modulationsystem.h"
#include "gig.h"

/**
 * Low Frequency Oscillator
 *
 * Synthesizes a triangular wave for modulating arbitrary synthesis
 * parameters.
 */
class LFO {
    public:
        /**
         * Defines how the LFO applies it's values to the synthesis
         * parameter matrix.
         */
        enum manipulation_type_t {
            manipulation_type_add,      ///< Add LFO's values to the synthesis paramter matrix.
            manipulation_type_multiply  ///< Multiply LFO's values with the ones from the synthesis parameter matrix.
        };
        /**
         * Defines the position of the LFO wave within the given value range
         * and from which value to start when the LFO is triggered.
         */
        enum propagation_t {
            propagation_top_down,        ///< Wave level starts from given max. and grows down with growing oscillator depth.
            propagation_middle_balanced, ///< Wave level starts from the middle of the given value range and grows in both directions with growing oscillator depth.
            propagation_bottom_up        ///< Wave level starts from given min. and grows up with growing oscillator depth.
        };

        uint8_t ExtController; ///< MIDI control change controller number if the LFO is controlled by an external controller, 0 otherwise.

        LFO(ModulationSystem::destination_t ModulationDestination, manipulation_type_t ManipulationType, float Min, float Max, propagation_t Propagation, RTELMemoryPool<ModulationSystem::Event>* pEventPool);
        void Process(uint Samples);
        void Trigger(float Frequency, uint16_t InternalDepth, uint16_t ExtControlDepth, uint16_t ExtControlValue, bool FlipPhase, uint Delay);
        void Reset();
        /**
         * Will be called by the voice to inform the LFO about a change of
         * the external controller's value.
         *
         * @param pEvent - control change event of external controller
         */
        inline void SendEvent(ModulationSystem::Event* pEvent) {
            if (ExtController && pEvent->FragmentPos() >= this->TriggerDelay) pEvents->alloc_assign(*pEvent);
        }
        ~LFO();
    protected:
        RTEList<ModulationSystem::Event>* pEvents;
        ModulationSystem::destination_t   ModulationDestination;
        manipulation_type_t               ManipulationType;
        propagation_t                     Propagation;
        int                               TriggerDelay;
        float                             Min;
        float                             Max;
        float                             CurrentMin;
        float                             CurrentMax;
        float                             FrequencyCoeff;
        float                             ExtControlDepthCoeff;
        float                             InternalDepth;
        float                             Range;
        float                             Coeff;
        float                             Level;

        inline void RecalculateCoeff(uint16_t ExtControlValue) {
            float currentrange = InternalDepth + ExtControlValue * ExtControlDepthCoeff;
            if (currentrange > Range) currentrange = Range;
            Coeff = (Coeff < 0) ? -(currentrange * FrequencyCoeff)
                                :   currentrange * FrequencyCoeff;
            switch (Propagation) {
                case propagation_top_down: {
                    CurrentMax = Max;
                    CurrentMin = Max - currentrange;
                    break;
                }
                case propagation_middle_balanced: {
                    float rangediff = (Range - currentrange) * 0.5f;
                    CurrentMax = Max - rangediff;
                    CurrentMin = Min + rangediff;
                    break;
                }
                case propagation_bottom_up: {
                    CurrentMax = Max - currentrange;
                    CurrentMin = Min;
                    break;
                }
            }
        }
};

#endif // __LFO_H__
1	schoenebeck	39	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck *
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., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			#ifndef __LFO_H__
24			#define __LFO_H__
25
26			#include "global.h"
27			#include "rtelmemorypool.h"
28			#include "modulationsystem.h"
29			#include "gig.h"
30
31			/**
32			* Low Frequency Oscillator
33			*
34			* Synthesizes a triangular wave for modulating arbitrary synthesis
35			* parameters.
36			*/
37			class LFO {
38			public:
39			/**
40			* Defines how the LFO applies it's values to the synthesis
41			* parameter matrix.
42			*/
43			enum manipulation_type_t {
44			manipulation_type_add, ///< Add LFO's values to the synthesis paramter matrix.
45			manipulation_type_multiply ///< Multiply LFO's values with the ones from the synthesis parameter matrix.
46			};
47			/**
48			* Defines the position of the LFO wave within the given value range
49			* and from which value to start when the LFO is triggered.
50			*/
51			enum propagation_t {
52			propagation_top_down, ///< Wave level starts from given max. and grows down with growing oscillator depth.
53			propagation_middle_balanced, ///< Wave level starts from the middle of the given value range and grows in both directions with growing oscillator depth.
54			propagation_bottom_up ///< Wave level starts from given min. and grows up with growing oscillator depth.
55			};
56
57			uint8_t ExtController; ///< MIDI control change controller number if the LFO is controlled by an external controller, 0 otherwise.
58
59			LFO(ModulationSystem::destination_t ModulationDestination, manipulation_type_t ManipulationType, float Min, float Max, propagation_t Propagation, RTELMemoryPool<ModulationSystem::Event>* pEventPool);
60			void Process(uint Samples);
61			void Trigger(float Frequency, uint16_t InternalDepth, uint16_t ExtControlDepth, uint16_t ExtControlValue, bool FlipPhase, uint Delay);
62			void Reset();
63			/**
64			* Will be called by the voice to inform the LFO about a change of
65			* the external controller's value.
66			*
67			* @param pEvent - control change event of external controller
68			*/
69			inline void SendEvent(ModulationSystem::Event* pEvent) {
70			if (ExtController && pEvent->FragmentPos() >= this->TriggerDelay) pEvents->alloc_assign(*pEvent);
71			}
72			~LFO();
73			protected:
74			RTEList<ModulationSystem::Event>* pEvents;
75			ModulationSystem::destination_t ModulationDestination;
76			manipulation_type_t ManipulationType;
77			propagation_t Propagation;
78			int TriggerDelay;
79			float Min;
80			float Max;
81			float CurrentMin;
82			float CurrentMax;
83			float FrequencyCoeff;
84			float ExtControlDepthCoeff;
85			float InternalDepth;
86			float Range;
87			float Coeff;
88			float Level;
89
90			inline void RecalculateCoeff(uint16_t ExtControlValue) {
91			float currentrange = InternalDepth + ExtControlValue * ExtControlDepthCoeff;
92			if (currentrange > Range) currentrange = Range;
93			Coeff = (Coeff < 0) ? -(currentrange * FrequencyCoeff)
94			: currentrange * FrequencyCoeff;
95			switch (Propagation) {
96			case propagation_top_down: {
97			CurrentMax = Max;
98			CurrentMin = Max - currentrange;
99			break;
100			}
101			case propagation_middle_balanced: {
102			float rangediff = (Range - currentrange) * 0.5f;
103			CurrentMax = Max - rangediff;
104			CurrentMin = Min + rangediff;
105			break;
106			}
107			case propagation_bottom_up: {
108			CurrentMax = Max - currentrange;
109			CurrentMin = Min;
110			break;
111			}
112			}
113			}
114			};
115
116			#endif // __LFO_H__