trunk/src/modulationsystem.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 __MODULATION_SYSTEM_H__
#define __MODULATION_SYSTEM_H__

#include "global.h"

/**
 * Handles modulation parameters and events for the current audio fragment.
 *
 * TODO: class should better be renamed to 'EventSystem' or even better: most of the attributes here could be moved into the engine and everything left would just be class Event (thus -> event.h and event.cpp), but that can wait until we restructe the source tree for multi engine support
 */
class ModulationSystem {
    public:
        enum destination_t {
            destination_vca,   ///< Volume level
            destination_vco,   ///< Pitch depth
            destination_vcfc,  ///< Filter curoff frequency
            destination_vcfr,  ///< Filter resonance
            destination_count  ///< Total number of modulation destinations (this has to stay the last element in the enum)
        };
        typedef uint32_t real_time_t; ///< We read the processor's cycle count register as a reference for the real time. These are of course only abstract values with arbitrary time entity, but that's not a problem as we calculate relatively.
        enum event_type_t {
            event_type_note_on,
            event_type_note_off,
            event_type_pitchbend,
            event_type_control_change,
            event_type_cancel_release,  ///< transformed either from a note-on or sustain-pedal-down event
            event_type_release          ///< transformed either from a note-off or sustain-pedal-up event
        };
        class Event {
            public:
                event_type_t Type;
                union {
                    uint8_t Key;          ///< MIDI key number for note-on and note-off events.
                    uint8_t Controller;   ///< MIDI controller number for control change events.
                };
                union {
                    uint8_t Velocity;     ///< Trigger or release velocity for note-on or note-off events.
                    uint8_t Value;        ///< Value for control change events.
                };
                int16_t Pitch;            ///< Pitch value for pitchbend events.

                Event() {
                    TimeStamp = ModulationSystem::CreateTimeStamp();
                    iFragmentPos = -1;
                }
                inline uint FragmentPos() {
                    if (iFragmentPos >= 0) return (uint) iFragmentPos;
                    return (uint) (iFragmentPos = ModulationSystem::ToFragmentPos(TimeStamp));
                }
            private:
                real_time_t TimeStamp;    ///< Time stamp of the event's occurence.
                int         iFragmentPos; ///< Position in the current fragment this event refers to.
        };

        static float** pDestinationParameter;

        static        void  Initialize(uint SampleRate, uint MaxSamplesPerCycle);
        static        void  Close();
        static        void  ResetDestinationParameter(ModulationSystem::destination_t dst, float val);
        static        void  UpdateFragmentTime();
        static real_time_t  CreateTimeStamp();
        static inline uint  MaxSamplesPerCycle()                  { return uiMaxSamplesPerCycle; }
        static inline uint  SampleRate()                          { return uiSampleRate;         }
        static inline uint  ToFragmentPos(real_time_t time_stamp) {
            return uint ((time_stamp - FragmentTime.begin) * FragmentTime.sample_ratio);
        }
    protected:
        static uint uiMaxSamplesPerCycle;
        static uint uiSampleRate;
        static struct __FragmentTime__ {
            real_time_t begin;         ///< Real time stamp of the beginning of this audio fragment cycle.
            real_time_t end;           ///< Real time stamp of the end of this audio fragment cycle.
            float       sample_ratio;  ///< (Samples per cycle) / (Real time duration of cycle)
        } FragmentTime;
};

#endif // __MODULATION_SYSTEM_H__
1	/***************************************************************************
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 __MODULATION_SYSTEM_H__
24	#define __MODULATION_SYSTEM_H__
25
26	#include "global.h"
27
28	/**
29	* Handles modulation parameters and events for the current audio fragment.
30	*
31	* TODO: class should better be renamed to 'EventSystem' or even better: most of the attributes here could be moved into the engine and everything left would just be class Event (thus -> event.h and event.cpp), but that can wait until we restructe the source tree for multi engine support
32	*/
33	class ModulationSystem {
34	public:
35	enum destination_t {
36	destination_vca, ///< Volume level
37	destination_vco, ///< Pitch depth
38	destination_vcfc, ///< Filter curoff frequency
39	destination_vcfr, ///< Filter resonance
40	destination_count ///< Total number of modulation destinations (this has to stay the last element in the enum)
41	};
42	typedef uint32_t real_time_t; ///< We read the processor's cycle count register as a reference for the real time. These are of course only abstract values with arbitrary time entity, but that's not a problem as we calculate relatively.
43	enum event_type_t {
44	event_type_note_on,
45	event_type_note_off,
46	event_type_pitchbend,
47	event_type_control_change,
48	event_type_cancel_release, ///< transformed either from a note-on or sustain-pedal-down event
49	event_type_release ///< transformed either from a note-off or sustain-pedal-up event
50	};
51	class Event {
52	public:
53	event_type_t Type;
54	union {
55	uint8_t Key; ///< MIDI key number for note-on and note-off events.
56	uint8_t Controller; ///< MIDI controller number for control change events.
57	};
58	union {
59	uint8_t Velocity; ///< Trigger or release velocity for note-on or note-off events.
60	uint8_t Value; ///< Value for control change events.
61	};
62	int16_t Pitch; ///< Pitch value for pitchbend events.
63
64	Event() {
65	TimeStamp = ModulationSystem::CreateTimeStamp();
66	iFragmentPos = -1;
67	}
68	inline uint FragmentPos() {
69	if (iFragmentPos >= 0) return (uint) iFragmentPos;
70	return (uint) (iFragmentPos = ModulationSystem::ToFragmentPos(TimeStamp));
71	}
72	private:
73	real_time_t TimeStamp; ///< Time stamp of the event's occurence.
74	int iFragmentPos; ///< Position in the current fragment this event refers to.
75	};
76
77	static float** pDestinationParameter;
78
79	static void Initialize(uint SampleRate, uint MaxSamplesPerCycle);
80	static void Close();
81	static void ResetDestinationParameter(ModulationSystem::destination_t dst, float val);
82	static void UpdateFragmentTime();
83	static real_time_t CreateTimeStamp();
84	static inline uint MaxSamplesPerCycle() { return uiMaxSamplesPerCycle; }
85	static inline uint SampleRate() { return uiSampleRate; }
86	static inline uint ToFragmentPos(real_time_t time_stamp) {
87	return uint ((time_stamp - FragmentTime.begin) * FragmentTime.sample_ratio);
88	}
89	protected:
90	static uint uiMaxSamplesPerCycle;
91	static uint uiSampleRate;
92	static struct __FragmentTime__ {
93	real_time_t begin; ///< Real time stamp of the beginning of this audio fragment cycle.
94	real_time_t end; ///< Real time stamp of the end of this audio fragment cycle.
95	float sample_ratio; ///< (Samples per cycle) / (Real time duration of cycle)
96	} FragmentTime;
97	};
98
99	#endif // __MODULATION_SYSTEM_H__