engines/common/Event.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 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 __LS_EVENT_H__
#define __LS_EVENT_H__

#include "../../common/global.h"

namespace LinuxSampler {

    // just symbol prototyping
    class Event;

    /**
     * Generates Event objects and is responsible for resolving the position
     * in the current audio fragment each Event actually belongs to.
     */
    class EventGenerator {
        public:
            EventGenerator(uint SampleRate);
            void UpdateFragmentTime(uint SamplesToProcess);
            Event CreateEvent();
        protected:
            typedef uint32_t time_stamp_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.
            inline uint ToFragmentPos(time_stamp_t TimeStamp) {
                return uint ((TimeStamp - FragmentTime.begin) * FragmentTime.sample_ratio);
            }
            friend class Event;
        private:
            uint uiSampleRate;
            uint uiSamplesProcessed;
            struct __FragmentTime__ {
                time_stamp_t begin;        ///< Real time stamp of the beginning of this audio fragment cycle.
                time_stamp_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;
            time_stamp_t CreateTimeStamp();
    };

    /**
     * Events are usually caused by a MIDI source or an internal modulation
     * controller like LFO or EG. An event can only be created by an
     * EventGenerator.
     *
     * @see EventGenerator
     */
    class Event {
        public:
            Event(){}
            enum type_t {
                type_note_on,
                type_note_off,
                type_pitchbend,
                type_control_change,
                type_sysex,           ///< MIDI system exclusive message
                type_cancel_release,  ///< transformed either from a note-on or sustain-pedal-down event
                type_release          ///< transformed either from a note-off or sustain-pedal-up event
            } Type;
            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)
            };
            union {
                /// Note-on and note-off event specifics
                struct _Note {
                    uint8_t Key;         ///< MIDI key number of note-on / note-off event.
                    uint8_t Velocity;    ///< Trigger or release velocity of note-on / note-off event.
                    int8_t  Layer;       ///< Layer index (usually only used if a note-on event has to be postponed, e.g. due to shortage of free voices).
                    int8_t  ReleaseTrigger; ///< If new voice should be a release triggered voice (actually boolean field and usually only used if a note-on event has to be postponed, e.g. due to shortage of free voices).
                } Note;
                /// Control change event specifics
                struct _CC {
                    uint8_t Controller;  ///< MIDI controller number of control change event.
                    uint8_t Value;       ///< Controller Value of control change event.
                } CC;
                /// Pitchbend event specifics
                struct _Pitch {
                    int16_t Pitch;       ///< Pitch value of pitchbend event.
                } Pitch;
                /// MIDI system exclusive event specifics
                struct _Sysex {
                    uint Size;           ///< Data length (in bytes) of MIDI system exclusive message.
                } Sysex;
            } Param;

            inline uint FragmentPos() {
                if (iFragmentPos >= 0) return (uint) iFragmentPos;
                return (uint) (iFragmentPos = pEventGenerator->ToFragmentPos(TimeStamp));
            }
        protected:
            typedef EventGenerator::time_stamp_t time_stamp_t;
            Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
            friend class EventGenerator;
        private:
            EventGenerator* pEventGenerator; ///< Creator of the event.
            time_stamp_t    TimeStamp;       ///< Time stamp of the event's occurence.
            int             iFragmentPos;    ///< Position in the current fragment this event refers to.
    };

} // namespace LinuxSampler

#endif // __LS_EVENT_H__
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 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 __LS_EVENT_H__
24	#define __LS_EVENT_H__
25
26	#include "../../common/global.h"
27
28	namespace LinuxSampler {
29
30	// just symbol prototyping
31	class Event;
32
33	/**
34	* Generates Event objects and is responsible for resolving the position
35	* in the current audio fragment each Event actually belongs to.
36	*/
37	class EventGenerator {
38	public:
39	EventGenerator(uint SampleRate);
40	void UpdateFragmentTime(uint SamplesToProcess);
41	Event CreateEvent();
42	protected:
43	typedef uint32_t time_stamp_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.
44	inline uint ToFragmentPos(time_stamp_t TimeStamp) {
45	return uint ((TimeStamp - FragmentTime.begin) * FragmentTime.sample_ratio);
46	}
47	friend class Event;
48	private:
49	uint uiSampleRate;
50	uint uiSamplesProcessed;
51	struct __FragmentTime__ {
52	time_stamp_t begin; ///< Real time stamp of the beginning of this audio fragment cycle.
53	time_stamp_t end; ///< Real time stamp of the end of this audio fragment cycle.
54	float sample_ratio; ///< (Samples per cycle) / (Real time duration of cycle)
55	} FragmentTime;
56	time_stamp_t CreateTimeStamp();
57	};
58
59	/**
60	* Events are usually caused by a MIDI source or an internal modulation
61	* controller like LFO or EG. An event can only be created by an
62	* EventGenerator.
63	*
64	* @see EventGenerator
65	*/
66	class Event {
67	public:
68	Event(){}
69	enum type_t {
70	type_note_on,
71	type_note_off,
72	type_pitchbend,
73	type_control_change,
74	type_sysex, ///< MIDI system exclusive message
75	type_cancel_release, ///< transformed either from a note-on or sustain-pedal-down event
76	type_release ///< transformed either from a note-off or sustain-pedal-up event
77	} Type;
78	enum destination_t {
79	destination_vca, ///< Volume level
80	destination_vco, ///< Pitch depth
81	destination_vcfc, ///< Filter curoff frequency
82	destination_vcfr, ///< Filter resonance
83	destination_count ///< Total number of modulation destinations (this has to stay the last element in the enum)
84	};
85	union {
86	/// Note-on and note-off event specifics
87	struct _Note {
88	uint8_t Key; ///< MIDI key number of note-on / note-off event.
89	uint8_t Velocity; ///< Trigger or release velocity of note-on / note-off event.
90	int8_t Layer; ///< Layer index (usually only used if a note-on event has to be postponed, e.g. due to shortage of free voices).
91	int8_t ReleaseTrigger; ///< If new voice should be a release triggered voice (actually boolean field and usually only used if a note-on event has to be postponed, e.g. due to shortage of free voices).
92	} Note;
93	/// Control change event specifics
94	struct _CC {
95	uint8_t Controller; ///< MIDI controller number of control change event.
96	uint8_t Value; ///< Controller Value of control change event.
97	} CC;
98	/// Pitchbend event specifics
99	struct _Pitch {
100	int16_t Pitch; ///< Pitch value of pitchbend event.
101	} Pitch;
102	/// MIDI system exclusive event specifics
103	struct _Sysex {
104	uint Size; ///< Data length (in bytes) of MIDI system exclusive message.
105	} Sysex;
106	} Param;
107
108	inline uint FragmentPos() {
109	if (iFragmentPos >= 0) return (uint) iFragmentPos;
110	return (uint) (iFragmentPos = pEventGenerator->ToFragmentPos(TimeStamp));
111	}
112	protected:
113	typedef EventGenerator::time_stamp_t time_stamp_t;
114	Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
115	friend class EventGenerator;
116	private:
117	EventGenerator* pEventGenerator; ///< Creator of the event.
118	time_stamp_t TimeStamp; ///< Time stamp of the event's occurence.
119	int iFragmentPos; ///< Position in the current fragment this event refers to.
120	};
121
122	} // namespace LinuxSampler
123
124	#endif // __LS_EVENT_H__