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_count  ///< Total number of modulation sources (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 an 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
        };
        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;
                };
                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_count ///< Total number of modulation sources (this has to stay the last element in the enum)
39	};
40	typedef uint32_t real_time_t; ///< We read the processor's cycle count register as an 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.
41	enum event_type_t {
42	event_type_note_on,
43	event_type_note_off,
44	event_type_pitchbend,
45	event_type_control_change
46	};
47	class Event {
48	public:
49	event_type_t Type;
50	union {
51	uint8_t Key; ///< MIDI key number for note-on and note-off events.
52	uint8_t Controller; ///< MIDI controller number for control change events.
53	};
54	union {
55	uint8_t Velocity; ///< Trigger or release velocity for note-on or note-off events.
56	uint8_t Value; ///< Value for control change events.
57	};
58	int16_t Pitch; ///< Pitch value for pitchbend events.
59
60	Event() {
61	TimeStamp = ModulationSystem::CreateTimeStamp();
62	iFragmentPos = -1;
63	};
64	uint FragmentPos() {
65	if (iFragmentPos >= 0) return (uint) iFragmentPos;
66	return (uint) (iFragmentPos = ModulationSystem::ToFragmentPos(TimeStamp));
67	};
68	private:
69	real_time_t TimeStamp; ///< Time stamp of the event's occurence.
70	int iFragmentPos; ///< Position in the current fragment this event refers to.
71	};
72
73	static float** pDestinationParameter;
74
75	static void Initialize(uint SampleRate, uint MaxSamplesPerCycle);
76	static void Close();
77	static void ResetDestinationParameter(ModulationSystem::destination_t dst, float val);
78	static void UpdateFragmentTime();
79	static real_time_t CreateTimeStamp();
80	static inline uint MaxSamplesPerCycle() { return uiMaxSamplesPerCycle; };
81	static inline uint SampleRate() { return uiSampleRate; };
82	static inline uint ToFragmentPos(real_time_t time_stamp) {
83	return uint ((time_stamp - FragmentTime.begin) * FragmentTime.sample_ratio);
84	};
85	protected:
86	static uint uiMaxSamplesPerCycle;
87	static uint uiSampleRate;
88	static struct __FragmentTime__ {
89	real_time_t begin; ///< Real time stamp of the beginning of this audio fragment cycle.
90	real_time_t end; ///< Real time stamp of the end of this audio fragment cycle.
91	float sample_ratio; ///< (Samples per cycle) / (Real time duration of cycle)
92	} FragmentTime;
93	};
94
95	#endif // __MODULATION_SYSTEM_H__