/[svn]/linuxsampler/trunk/src/engines/common/Event.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/Event.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2559 - (show annotations) (download) (as text)
Sun May 18 17:38:25 2014 UTC (9 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 7739 byte(s)
* Aftertouch: extended API to explicitly handle channel pressure and
  polyphonic key pressure events (so far polyphonic pressure was not
  supported at all, and channel pressure was rerouted as CC128 but not
  used so far).
* Gig Engine: Fixed support for 'aftertouch' attenuation controller.
* Bumped version (1.0.0.svn39).

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * Copyright (C) 2005 - 2014 Christian Schoenebeck *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __LS_EVENT_H__
25 #define __LS_EVENT_H__
26
27 #include "../../common/global.h"
28 #include "../../common/RTMath.h"
29 #include "../EngineChannel.h"
30
31 namespace LinuxSampler {
32
33 // just symbol prototyping
34 class Event;
35
36 /**
37 * Generates Event objects and is responsible for resolving the position
38 * in the current audio fragment each Event actually belongs to.
39 */
40 class EventGenerator {
41 public:
42 EventGenerator(uint SampleRate);
43 void UpdateFragmentTime(uint SamplesToProcess);
44 Event CreateEvent();
45 Event CreateEvent(int32_t FragmentPos);
46 protected:
47 typedef RTMath::time_stamp_t time_stamp_t;
48 inline int32_t ToFragmentPos(time_stamp_t TimeStamp) {
49 return int32_t (int32_t(TimeStamp - FragmentTime.begin) * FragmentTime.sample_ratio);
50 }
51 friend class Event;
52 private:
53 uint uiSampleRate;
54 uint uiSamplesProcessed;
55 struct __FragmentTime__ {
56 time_stamp_t begin; ///< Real time stamp of the beginning of this audio fragment cycle.
57 time_stamp_t end; ///< Real time stamp of the end of this audio fragment cycle.
58 float sample_ratio; ///< (Samples per cycle) / (Real time duration of cycle)
59 } FragmentTime;
60 };
61
62 /**
63 * Events are usually caused by a MIDI source or an internal modulation
64 * controller like LFO or EG. An event should only be created by an
65 * EventGenerator!
66 *
67 * @see EventGenerator
68 */
69 class Event {
70 public:
71 Event(){}
72 enum type_t {
73 type_note_on,
74 type_note_off,
75 type_pitchbend,
76 type_control_change,
77 type_sysex, ///< MIDI system exclusive message
78 type_cancel_release, ///< transformed either from a note-on or sustain-pedal-down event
79 type_release, ///< transformed either from a note-off or sustain-pedal-up event
80 type_channel_pressure, ///< a.k.a. aftertouch
81 type_note_pressure, ///< polyphonic key pressure (aftertouch)
82 } Type;
83 union {
84 /// Note-on and note-off event specifics
85 struct _Note {
86 uint8_t Key; ///< MIDI key number of note-on / note-off event.
87 uint8_t Velocity; ///< Trigger or release velocity of note-on / note-off event.
88 uint8_t Channel; ///< MIDI channel (0..15)
89 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).
90 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).
91 void* pRegion; ///< Engine specific pointer to instrument region
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 uint8_t Channel; ///< MIDI channel (0..15)
98 } CC;
99 /// Pitchbend event specifics
100 struct _Pitch {
101 int16_t Pitch; ///< Pitch value of pitchbend event.
102 uint8_t Channel; ///< MIDI channel (0..15)
103 } Pitch;
104 /// MIDI system exclusive event specifics
105 struct _Sysex {
106 uint Size; ///< Data length (in bytes) of MIDI system exclusive message.
107 } Sysex;
108 /// Channel Pressure (aftertouch) event specifics
109 struct _ChannelPressure {
110 uint8_t Value; ///< New aftertouch / pressure value for keys on that channel.
111 uint8_t Channel; ///< MIDI channel (0..15)
112 } ChannelPressure;
113 /// Polyphonic Note Pressure (aftertouch) event specifics
114 struct _NotePressure {
115 uint8_t Key; ///< MIDI note number where key pressure (polyphonic aftertouch) changed.
116 uint8_t Value; ///< New pressure value for note.
117 uint8_t Channel; ///< MIDI channel (0..15)
118 } NotePressure;
119 } Param;
120 EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).
121 MidiInputPort* pMidiInputPort; ///< Pointer to the MIDI input port on which this event occured (NOTE: currently only for global events, that is SysEx messages)
122
123 inline int32_t FragmentPos() {
124 if (iFragmentPos >= 0) return iFragmentPos;
125 iFragmentPos = pEventGenerator->ToFragmentPos(TimeStamp);
126 if (iFragmentPos < 0) iFragmentPos = 0; // if event arrived shortly before the beginning of current fragment
127 return iFragmentPos;
128 }
129 inline void ResetFragmentPos() {
130 iFragmentPos = -1;
131 }
132 protected:
133 typedef EventGenerator::time_stamp_t time_stamp_t;
134 Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
135 Event(EventGenerator* pGenerator, int32_t FragmentPos);
136 friend class EventGenerator;
137 private:
138 EventGenerator* pEventGenerator; ///< Creator of the event.
139 time_stamp_t TimeStamp; ///< Time stamp of the event's occurence.
140 int32_t iFragmentPos; ///< Position in the current fragment this event refers to.
141 };
142
143 } // namespace LinuxSampler
144
145 #endif // __LS_EVENT_H__

  ViewVC Help
Powered by ViewVC