/[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 2594 - (show annotations) (download) (as text)
Thu Jun 5 00:16:25 2014 UTC (9 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 8612 byte(s) 
* ScriptVM (WIP): started to integrate real-time instrument script
  support into the sampler engine implementations. The code is
  shared among all sampler engines, however currently only the gig
  file format supports storing instrument scripts (as LinuxSampler
  extension to the original GigaStudio 4 file format).
* gig engine: Added support for loading instrument scripts from .gig
  files.
* ScriptVM (WIP): Implemented built-in script variables %CC, $CC_NUM,
  $EVENT_NOTE, $EVENT_VELOCITY, $VCC_MONO_AT, $VCC_PITCH_BEND.
* ScriptVM (WIP): Implemented execution of script event handler "init".
* ScriptVM (WIP): Implemented execution of script event handler
  "controller".
* Bumped version (1.0.0.svn42).
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, ScriptEvent
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 class VMEventHandler;
144 class VMExecContext;
145
146 /** @brief Real-time instrument script event.
147 *
148 * Encapsulates one execution instance of a real-time instrument script for
149 * exactly one script event handler (script event callback).
150 */
151 class ScriptEvent {
152 public:
153 Event cause; ///< Original external event that triggered this script event (i.e. MIDI note on event, MIDI CC event, etc.).
154 VMEventHandler** handlers; ///< The script's event handlers (callbacks) to be processed (NULL terminated list).
155 VMExecContext* execCtx; ///< Script's current execution state (polyphonic variables and execution stack).
156 int currentHandler; ///< Current index in 'handlers' list above.
157 int executionSlices; ///< Amount of times this script event has been executed by the ScriptVM runner class.
158 };
159
160 } // namespace LinuxSampler
161
162 #endif // __LS_EVENT_H__
  ViewVC Help
Powered by ViewVC