/[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 2611 - (hide annotations) (download) (as text)
Mon Jun 9 19:20:37 2014 UTC (9 years, 10 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 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 schoenebeck 2594 * @see EventGenerator, ScriptEvent
68 schoenebeck 53 */
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 schoenebeck 2600 uint8_t Channel; ///< MIDI channel (0..15)
87 schoenebeck 246 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 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 schoenebeck 2600 uint8_t Channel; ///< MIDI channel (0..15)
96 schoenebeck 246 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 schoenebeck 2600 uint8_t Channel; ///< MIDI channel (0..15)
102 schoenebeck 246 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 schoenebeck 2559 /// Channel Pressure (aftertouch) event specifics
109     struct _ChannelPressure {
110 schoenebeck 2600 uint8_t Channel; ///< MIDI channel (0..15)
111 schoenebeck 2611 uint8_t Controller; ///< Should always be assigned to CTRL_TABLE_IDX_AFTERTOUCH.
112 schoenebeck 2559 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 schoenebeck 2600 uint8_t Channel; ///< MIDI channel (0..15)
117 schoenebeck 2559 uint8_t Key; ///< MIDI note number where key pressure (polyphonic aftertouch) changed.
118     uint8_t Value; ///< New pressure value for note.
119     } NotePressure;
120 schoenebeck 246 } Param;
121 schoenebeck 2600 /// 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 schoenebeck 412 EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).
130 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)
131 schoenebeck 53
132 schoenebeck 293 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 schoenebeck 53 }
138 schoenebeck 293 inline void ResetFragmentPos() {
139     iFragmentPos = -1;
140     }
141 schoenebeck 53 protected:
142     typedef EventGenerator::time_stamp_t time_stamp_t;
143     Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
144 schoenebeck 906 Event(EventGenerator* pGenerator, int32_t FragmentPos);
145 schoenebeck 53 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 schoenebeck 293 int32_t iFragmentPos; ///< Position in the current fragment this event refers to.
150 schoenebeck 53 };
151    
152 schoenebeck 2594 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 schoenebeck 2598 int id; ///< Unique ID of the external event that triggered this cript event.
164 schoenebeck 2594 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 schoenebeck 53 } // namespace LinuxSampler
171    
172     #endif // __LS_EVENT_H__
  ViewVC Help
Powered by ViewVC