/[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 2611 - (show annotations) (download) (as text)
Mon Jun 9 19:20:37 2014 UTC (5 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 9368 byte(s)
* Fixed crash when loading an instrument script.
* Fixed "init" script handler only to be executed once:
  when the script was loaded.
* Fixed aftertouch script event which always had value zero
  and controller number was set to aftertouch value instead.
* gig Engine: Fixed handling of "smartmidi" dimension, which
  was recognized as "unknown" dimension.
* Fixed script function gig_set_dim_zone(): was accessing
  wrong event.
* ls_instr_script command line tool: is now not limited to
  core language scripts, but can now also parse sampler format
  dependent instrument scripts, with the respective specific
  built-in script variables and functions.
* ScriptVM: Fixed runtime behavior of "and" and "or" binary
  script expressions, which also evaluated the right hand side
  of the expression even if the left hand side already failed
  the overall expression semantic to become true.
* Bumped version (1.0.0.svn46).

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 Channel; ///< MIDI channel (0..15)
87 uint8_t Key; ///< MIDI key number of note-on / note-off event.
88 uint8_t Velocity; ///< Trigger or release velocity of note-on / note-off event.
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 Channel; ///< MIDI channel (0..15)
96 uint8_t Controller; ///< MIDI controller number of control change event.
97 uint8_t Value; ///< Controller Value of control change event.
98 } CC;
99 /// Pitchbend event specifics
100 struct _Pitch {
101 uint8_t Channel; ///< MIDI channel (0..15)
102 int16_t Pitch; ///< Pitch value of pitchbend event.
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 Channel; ///< MIDI channel (0..15)
111 uint8_t Controller; ///< Should always be assigned to CTRL_TABLE_IDX_AFTERTOUCH.
112 uint8_t Value; ///< New aftertouch / pressure value for keys on that channel.
113 } ChannelPressure;
114 /// Polyphonic Note Pressure (aftertouch) event specifics
115 struct _NotePressure {
116 uint8_t Channel; ///< MIDI channel (0..15)
117 uint8_t Key; ///< MIDI note number where key pressure (polyphonic aftertouch) changed.
118 uint8_t Value; ///< New pressure value for note.
119 } NotePressure;
120 } Param;
121 /// Sampler format specific informations and variables.
122 union {
123 /// Gigasampler/GigaStudio format specifics.
124 struct _Gig {
125 uint8_t DimMask; ///< May be used to override the Dimension zone to be selected for a new voice: each 1 bit means that respective bit shall be overridden by taking the respective bit from DimBits instead.
126 uint8_t DimBits; ///< Used only in conjunction with DimMask: Dimension bits that shall be selected.
127 } Gig;
128 } Format;
129 EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).
130 MidiInputPort* pMidiInputPort; ///< Pointer to the MIDI input port on which this event occured (NOTE: currently only for global events, that is SysEx messages)
131
132 inline int32_t FragmentPos() {
133 if (iFragmentPos >= 0) return iFragmentPos;
134 iFragmentPos = pEventGenerator->ToFragmentPos(TimeStamp);
135 if (iFragmentPos < 0) iFragmentPos = 0; // if event arrived shortly before the beginning of current fragment
136 return iFragmentPos;
137 }
138 inline void ResetFragmentPos() {
139 iFragmentPos = -1;
140 }
141 protected:
142 typedef EventGenerator::time_stamp_t time_stamp_t;
143 Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
144 Event(EventGenerator* pGenerator, int32_t FragmentPos);
145 friend class EventGenerator;
146 private:
147 EventGenerator* pEventGenerator; ///< Creator of the event.
148 time_stamp_t TimeStamp; ///< Time stamp of the event's occurence.
149 int32_t iFragmentPos; ///< Position in the current fragment this event refers to.
150 };
151
152 class VMEventHandler;
153 class VMExecContext;
154
155 /** @brief Real-time instrument script event.
156 *
157 * Encapsulates one execution instance of a real-time instrument script for
158 * exactly one script event handler (script event callback).
159 */
160 class ScriptEvent {
161 public:
162 Event cause; ///< Original external event that triggered this script event (i.e. MIDI note on event, MIDI CC event, etc.).
163 int id; ///< Unique ID of the external event that triggered this cript event.
164 VMEventHandler** handlers; ///< The script's event handlers (callbacks) to be processed (NULL terminated list).
165 VMExecContext* execCtx; ///< Script's current execution state (polyphonic variables and execution stack).
166 int currentHandler; ///< Current index in 'handlers' list above.
167 int executionSlices; ///< Amount of times this script event has been executed by the ScriptVM runner class.
168 };
169
170 } // namespace LinuxSampler
171
172 #endif // __LS_EVENT_H__

  ViewVC Help
Powered by ViewVC