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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2559 - (hide 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 schoenebeck 53 /***************************************************************************
2     * *
3     * LinuxSampler - modular, streaming capable sampler *
4     * *
5 schoenebeck 56 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 schoenebeck 2559 * Copyright (C) 2005 - 2014 Christian Schoenebeck *
7 schoenebeck 53 * *
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 schoenebeck 328 #include "../../common/RTMath.h"
29 schoenebeck 890 #include "../EngineChannel.h"
30 schoenebeck 53
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 schoenebeck 906 Event CreateEvent(int32_t FragmentPos);
46 schoenebeck 53 protected:
47 schoenebeck 328 typedef RTMath::time_stamp_t time_stamp_t;
48 schoenebeck 293 inline int32_t ToFragmentPos(time_stamp_t TimeStamp) {
49     return int32_t (int32_t(TimeStamp - FragmentTime.begin) * FragmentTime.sample_ratio);
50 schoenebeck 53 }
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 schoenebeck 906 * controller like LFO or EG. An event should only be created by an
65     * EventGenerator!
66 schoenebeck 53 *
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 schoenebeck 244 type_sysex, ///< MIDI system exclusive message
78 schoenebeck 53 type_cancel_release, ///< transformed either from a note-on or sustain-pedal-down event
79 schoenebeck 2559 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 schoenebeck 53 } Type;
83     union {
84 schoenebeck 246 /// 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 persson 2317 uint8_t Channel; ///< MIDI channel (0..15)
89 schoenebeck 250 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 persson 2101 void* pRegion; ///< Engine specific pointer to instrument region
92 schoenebeck 246 } 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 persson 2317 uint8_t Channel; ///< MIDI channel (0..15)
98 schoenebeck 246 } CC;
99     /// Pitchbend event specifics
100     struct _Pitch {
101     int16_t Pitch; ///< Pitch value of pitchbend event.
102 persson 2317 uint8_t Channel; ///< MIDI channel (0..15)
103 schoenebeck 246 } 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 schoenebeck 2559 /// 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 schoenebeck 246 } Param;
120 schoenebeck 412 EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).
121 schoenebeck 1751 MidiInputPort* pMidiInputPort; ///< Pointer to the MIDI input port on which this event occured (NOTE: currently only for global events, that is SysEx messages)
122 schoenebeck 53
123 schoenebeck 293 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 schoenebeck 53 }
129 schoenebeck 293 inline void ResetFragmentPos() {
130     iFragmentPos = -1;
131     }
132 schoenebeck 53 protected:
133     typedef EventGenerator::time_stamp_t time_stamp_t;
134     Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
135 schoenebeck 906 Event(EventGenerator* pGenerator, int32_t FragmentPos);
136 schoenebeck 53 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 schoenebeck 293 int32_t iFragmentPos; ///< Position in the current fragment this event refers to.
141 schoenebeck 53 };
142    
143     } // namespace LinuxSampler
144    
145     #endif // __LS_EVENT_H__

  ViewVC Help
Powered by ViewVC