/[svn]/linuxsampler/trunk/src/engines/common/InstrumentScriptVM.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/InstrumentScriptVM.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3255 - (show annotations) (download)
Tue May 30 15:43:39 2017 UTC (6 years, 10 months ago) by schoenebeck
File size: 17089 byte(s)
* NKSP: Implemented built-in script function "change_play_pos()".
* Bumped version (2.0.0.svn57).

1 /*
2 * Copyright (c) 2014 - 2017 Christian Schoenebeck
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 #include "../../common/global_private.h"
11 #include "InstrumentScriptVM.h"
12 #include "../AbstractEngineChannel.h"
13 #include "../../common/global_private.h"
14 #include "AbstractInstrumentManager.h"
15 #include "MidiKeyboardManager.h"
16 #include "Fade.h"
17
18 namespace LinuxSampler {
19
20 ///////////////////////////////////////////////////////////////////////
21 // class 'EventGroup'
22
23 void EventGroup::insert(int eventID) {
24 if (contains(eventID)) return;
25
26 AbstractEngine* pEngine = m_script->pEngineChannel->pEngine;
27
28 // before adding the new event ID, check if there are any dead events
29 // and remove them in that case, before otherwise we might run in danger
30 // to run out of free space on this group for event IDs if a lot of
31 // events die before being removed explicitly from the group by script
32 //
33 // NOTE: or should we do this "dead ones" check only once in a while?
34 int firstDead = -1;
35 for (int i = 0; i < size(); ++i) {
36 if (firstDead >= 0) {
37 if (pEngine->EventByID(eventID)) {
38 remove(firstDead, i - firstDead);
39 firstDead = -1;
40 }
41 } else {
42 if (!pEngine->EventByID(eventID)) firstDead = i;
43 }
44 }
45
46 append(eventID);
47 }
48
49 void EventGroup::erase(int eventID) {
50 int index = find(eventID);
51 remove(index);
52 }
53
54 ///////////////////////////////////////////////////////////////////////
55 // class 'InstrumentScript'
56
57 InstrumentScript::InstrumentScript(AbstractEngineChannel* pEngineChannel) {
58 parserContext = NULL;
59 bHasValidScript = false;
60 handlerInit = NULL;
61 handlerNote = NULL;
62 handlerRelease = NULL;
63 handlerController = NULL;
64 pEvents = NULL;
65 for (int i = 0; i < 128; ++i)
66 pKeyEvents[i] = NULL;
67 this->pEngineChannel = pEngineChannel;
68 for (int i = 0; i < INSTR_SCRIPT_EVENT_GROUPS; ++i)
69 eventGroups[i].setScript(this);
70 }
71
72 InstrumentScript::~InstrumentScript() {
73 resetAll();
74 if (pEvents) {
75 for (int i = 0; i < 128; ++i) delete pKeyEvents[i];
76 delete pEvents;
77 }
78 }
79
80 /** @brief Load real-time instrument script.
81 *
82 * Loads the real-time instrument script given by @a text on the engine
83 * channel this InstrumentScript object belongs to (defined by
84 * pEngineChannel member variable). The sampler engine's resource manager is
85 * used to allocate and share equivalent scripts on multiple engine
86 * channels.
87 *
88 * @param text - source code of script
89 */
90 void InstrumentScript::load(const String& text) {
91 dmsg(1,("Loading real-time instrument script ... "));
92
93 // hand back old script reference and VM execution contexts
94 // (if not done already)
95 unload();
96
97 code = text;
98
99 AbstractInstrumentManager* pManager =
100 dynamic_cast<AbstractInstrumentManager*>(pEngineChannel->pEngine->GetInstrumentManager());
101
102 // get new script reference
103 parserContext = pManager->scripts.Borrow(text, pEngineChannel);
104 if (!parserContext->errors().empty()) {
105 std::vector<ParserIssue> errors = parserContext->errors();
106 std::cerr << "[ScriptVM] Could not load instrument script, there were "
107 << errors.size() << " parser errors:\n";
108 for (int i = 0; i < errors.size(); ++i)
109 errors[i].dump();
110 return; // stop here if there were any parser errors
111 }
112
113 handlerInit = parserContext->eventHandlerByName("init");
114 handlerNote = parserContext->eventHandlerByName("note");
115 handlerRelease = parserContext->eventHandlerByName("release");
116 handlerController = parserContext->eventHandlerByName("controller");
117 bHasValidScript =
118 handlerInit || handlerNote || handlerRelease || handlerController;
119
120 // amount of script handlers each script event has to execute
121 int handlerExecCount = 0;
122 if (handlerNote || handlerRelease || handlerController) // only one of these are executed after "init" handler
123 handlerExecCount++;
124
125 // create script event pool (if it doesn't exist already)
126 if (!pEvents) {
127 pEvents = new Pool<ScriptEvent>(CONFIG_MAX_EVENTS_PER_FRAGMENT);
128 for (int i = 0; i < 128; ++i)
129 pKeyEvents[i] = new RTList<ScriptEvent>(pEvents);
130 // reset RTAVLNode's tree node member variables after nodes are allocated
131 // (since we can't use a constructor right now, we do that initialization here)
132 while (!pEvents->poolIsEmpty()) {
133 RTList<ScriptEvent>::Iterator it = pEvents->allocAppend();
134 it->reset();
135 }
136 pEvents->clear();
137 }
138
139 // create new VM execution contexts for new script
140 while (!pEvents->poolIsEmpty()) {
141 RTList<ScriptEvent>::Iterator it = pEvents->allocAppend();
142 it->execCtx = pEngineChannel->pEngine->pScriptVM->createExecContext(
143 parserContext
144 );
145 it->handlers = new VMEventHandler*[handlerExecCount+1];
146 }
147 pEvents->clear();
148
149 dmsg(1,("Done\n"));
150 }
151
152 /** @brief Unload real-time instrument script.
153 *
154 * Unloads the currently used real-time instrument script and frees all
155 * resources allocated for that script. The sampler engine's resource manager
156 * is used to share equivalent scripts among multiple sampler channels, and
157 * to deallocate the parsed script once not used on any engine channel
158 * anymore.
159 *
160 * Calling this method will however not clear the @c code member variable.
161 * Thus, the script can be parsed again afterwards.
162 */
163 void InstrumentScript::unload() {
164 //dmsg(1,("InstrumentScript::unload(this=0x%llx)\n", this));
165
166 if (parserContext)
167 dmsg(1,("Unloading current instrument script.\n"));
168
169 resetEvents();
170
171 // free allocated VM execution contexts
172 if (pEvents) {
173 pEvents->clear();
174 while (!pEvents->poolIsEmpty()) {
175 RTList<ScriptEvent>::Iterator it = pEvents->allocAppend();
176 if (it->execCtx) {
177 // free VM execution context object
178 delete it->execCtx;
179 it->execCtx = NULL;
180 // free C array of handler pointers
181 delete [] it->handlers;
182 }
183 }
184 pEvents->clear();
185 }
186 // hand back VM representation of script
187 if (parserContext) {
188 AbstractInstrumentManager* pManager =
189 dynamic_cast<AbstractInstrumentManager*>(pEngineChannel->pEngine->GetInstrumentManager());
190
191 pManager->scripts.HandBack(parserContext, pEngineChannel);
192 parserContext = NULL;
193 handlerInit = NULL;
194 handlerNote = NULL;
195 handlerRelease = NULL;
196 handlerController = NULL;
197 }
198 bHasValidScript = false;
199 }
200
201 /**
202 * Same as unload(), but this one also empties the @c code member variable
203 * to an empty string.
204 */
205 void InstrumentScript::resetAll() {
206 unload();
207 code.clear();
208 }
209
210 /**
211 * Clears all currently active script events. This should be called
212 * whenever the engine or engine channel was reset for some reason.
213 */
214 void InstrumentScript::resetEvents() {
215 for (int i = 0; i < INSTR_SCRIPT_EVENT_GROUPS; ++i)
216 eventGroups[i].clear();
217
218 for (int i = 0; i < 128; ++i)
219 if (pKeyEvents[i])
220 pKeyEvents[i]->clear();
221
222 suspendedEvents.clear();
223
224 if (pEvents) pEvents->clear();
225 }
226
227 ///////////////////////////////////////////////////////////////////////
228 // class 'InstrumentScriptVM'
229
230 InstrumentScriptVM::InstrumentScriptVM() :
231 m_event(NULL), m_fnPlayNote(this), m_fnSetController(this),
232 m_fnIgnoreEvent(this), m_fnIgnoreController(this), m_fnNoteOff(this),
233 m_fnSetEventMark(this), m_fnDeleteEventMark(this), m_fnByMarks(this),
234 m_fnChangeVol(this), m_fnChangeVolTime(this),
235 m_fnChangeTune(this), m_fnChangeTuneTime(this), m_fnChangePan(this),
236 m_fnChangeCutoff(this), m_fnChangeReso(this), m_fnChangeAttack(this),
237 m_fnChangeDecay(this), m_fnChangeRelease(this),
238 m_fnChangeAmpLFODepth(this), m_fnChangeAmpLFOFreq(this),
239 m_fnChangePitchLFODepth(this), m_fnChangePitchLFOFreq(this),
240 m_fnChangeNote(this), m_fnChangeVelo(this),
241 m_fnEventStatus(this), m_fnWait2(this), m_fnStopWait(this),
242 m_fnFadeIn(this), m_fnFadeOut(this),
243 m_fnChangeVolCurve(this), m_fnChangeTuneCurve(this),
244 m_fnGetEventPar(this), m_fnSetEventPar(this), m_fnChangePlayPos(this),
245 m_varEngineUptime(this), m_varCallbackID(this), m_varAllEvents(this)
246 {
247 m_CC.size = _MEMBER_SIZEOF(AbstractEngineChannel, ControllerTable);
248 m_CC_NUM = DECLARE_VMINT(m_event, class ScriptEvent, cause.Param.CC.Controller);
249 m_EVENT_ID = DECLARE_VMINT_READONLY(m_event, class ScriptEvent, id);
250 m_EVENT_NOTE = DECLARE_VMINT_READONLY(m_event, class ScriptEvent, cause.Param.Note.Key);
251 m_EVENT_VELOCITY = DECLARE_VMINT_READONLY(m_event, class ScriptEvent, cause.Param.Note.Velocity);
252 m_KEY_DOWN.size = 128;
253 m_KEY_DOWN.readonly = true;
254 m_NI_CALLBACK_TYPE = DECLARE_VMINT_READONLY(m_event, class ScriptEvent, handlerType);
255 m_NKSP_IGNORE_WAIT = DECLARE_VMINT(m_event, class ScriptEvent, ignoreAllWaitCalls);
256 }
257
258 VMExecStatus_t InstrumentScriptVM::exec(VMParserContext* parserCtx, ScriptEvent* event) {
259 AbstractEngineChannel* pEngineChannel =
260 static_cast<AbstractEngineChannel*>(event->cause.pEngineChannel);
261
262 // prepare built-in script variables for script execution
263 m_event = event;
264 m_CC.data = (int8_t*) &pEngineChannel->ControllerTable[0];
265 m_KEY_DOWN.data = &pEngineChannel->GetMidiKeyboardManager()->KeyDown[0];
266
267 // if script is in start condition, then do mandatory MIDI event
268 // preprocessing tasks, which essentially means updating i.e. controller
269 // table with new CC value in case of a controller event, because the
270 // script might access the new CC value
271 if (!event->executionSlices) {
272 switch (event->cause.Type) {
273 case Event::type_control_change:
274 pEngineChannel->ControllerTable[event->cause.Param.CC.Controller] =
275 event->cause.Param.CC.Value;
276 break;
277 case Event::type_channel_pressure:
278 pEngineChannel->ControllerTable[CTRL_TABLE_IDX_AFTERTOUCH] =
279 event->cause.Param.ChannelPressure.Value;
280 break;
281 case Event::type_pitchbend:
282 pEngineChannel->ControllerTable[CTRL_TABLE_IDX_PITCHBEND] =
283 event->cause.Param.Pitch.Pitch;
284 break;
285 default:
286 ; // noop
287 }
288 }
289
290 // run the script handler(s)
291 VMExecStatus_t res = VM_EXEC_NOT_RUNNING;
292 for ( ; event->handlers[event->currentHandler]; event->currentHandler++) {
293 res = ScriptVM::exec(
294 parserCtx, event->execCtx, event->handlers[event->currentHandler]
295 );
296 event->executionSlices++;
297 if (res & VM_EXEC_SUSPENDED || res & VM_EXEC_ERROR) return res;
298 }
299
300 return res;
301 }
302
303 std::map<String,VMIntRelPtr*> InstrumentScriptVM::builtInIntVariables() {
304 // first get built-in integer variables of derived VM class
305 std::map<String,VMIntRelPtr*> m = ScriptVM::builtInIntVariables();
306
307 // now add own built-in variables
308 m["$CC_NUM"] = &m_CC_NUM;
309 m["$EVENT_ID"] = &m_EVENT_ID;
310 m["$EVENT_NOTE"] = &m_EVENT_NOTE;
311 m["$EVENT_VELOCITY"] = &m_EVENT_VELOCITY;
312 // m["$POLY_AT_NUM"] = &m_POLY_AT_NUM;
313 m["$NI_CALLBACK_TYPE"] = &m_NI_CALLBACK_TYPE;
314 m["$NKSP_IGNORE_WAIT"] = &m_NKSP_IGNORE_WAIT;
315
316 return m;
317 }
318
319 std::map<String,VMInt8Array*> InstrumentScriptVM::builtInIntArrayVariables() {
320 // first get built-in integer array variables of derived VM class
321 std::map<String,VMInt8Array*> m = ScriptVM::builtInIntArrayVariables();
322
323 // now add own built-in variables
324 m["%CC"] = &m_CC;
325 m["%KEY_DOWN"] = &m_KEY_DOWN;
326 //m["%POLY_AT"] = &m_POLY_AT;
327
328 return m;
329 }
330
331 std::map<String,int> InstrumentScriptVM::builtInConstIntVariables() {
332 // first get built-in integer variables of derived VM class
333 std::map<String,int> m = ScriptVM::builtInConstIntVariables();
334
335 m["$EVENT_STATUS_INACTIVE"] = EVENT_STATUS_INACTIVE;
336 m["$EVENT_STATUS_NOTE_QUEUE"] = EVENT_STATUS_NOTE_QUEUE;
337 m["$VCC_MONO_AT"] = CTRL_TABLE_IDX_AFTERTOUCH;
338 m["$VCC_PITCH_BEND"] = CTRL_TABLE_IDX_PITCHBEND;
339 for (int i = 0; i < INSTR_SCRIPT_EVENT_GROUPS; ++i) {
340 m["$MARK_" + ToString(i+1)] = i;
341 }
342 m["$EVENT_PAR_NOTE"] = EVENT_PAR_NOTE;
343 m["$EVENT_PAR_VELOCITY"] = EVENT_PAR_VELOCITY;
344 m["$EVENT_PAR_VOLUME"] = EVENT_PAR_VOLUME;
345 m["$EVENT_PAR_TUNE"] = EVENT_PAR_TUNE;
346 m["$EVENT_PAR_0"] = EVENT_PAR_0;
347 m["$EVENT_PAR_1"] = EVENT_PAR_1;
348 m["$EVENT_PAR_2"] = EVENT_PAR_2;
349 m["$EVENT_PAR_3"] = EVENT_PAR_3;
350 m["$NKSP_LINEAR"] = FADE_CURVE_LINEAR;
351 m["$NKSP_EASE_IN_EASE_OUT"] = FADE_CURVE_EASE_IN_EASE_OUT;
352
353 return m;
354 }
355
356 std::map<String,VMDynVar*> InstrumentScriptVM::builtInDynamicVariables() {
357 // first get built-in dynamic variables of derived VM class
358 std::map<String,VMDynVar*> m = ScriptVM::builtInDynamicVariables();
359
360 m["%ALL_EVENTS"] = &m_varAllEvents;
361 m["$ENGINE_UPTIME"] = &m_varEngineUptime;
362 m["$NI_CALLBACK_ID"] = &m_varCallbackID;
363
364 return m;
365 }
366
367 VMFunction* InstrumentScriptVM::functionByName(const String& name) {
368 // built-in script functions of this class
369 if (name == "play_note") return &m_fnPlayNote;
370 else if (name == "set_controller") return &m_fnSetController;
371 else if (name == "ignore_event") return &m_fnIgnoreEvent;
372 else if (name == "ignore_controller") return &m_fnIgnoreController;
373 else if (name == "note_off") return &m_fnNoteOff;
374 else if (name == "set_event_mark") return &m_fnSetEventMark;
375 else if (name == "delete_event_mark") return &m_fnDeleteEventMark;
376 else if (name == "by_marks") return &m_fnByMarks;
377 else if (name == "change_vol") return &m_fnChangeVol;
378 else if (name == "change_vol_time") return &m_fnChangeVolTime;
379 else if (name == "change_tune") return &m_fnChangeTune;
380 else if (name == "change_tune_time") return &m_fnChangeTuneTime;
381 else if (name == "change_note") return &m_fnChangeNote;
382 else if (name == "change_velo") return &m_fnChangeVelo;
383 else if (name == "change_pan") return &m_fnChangePan;
384 else if (name == "change_cutoff") return &m_fnChangeCutoff;
385 else if (name == "change_reso") return &m_fnChangeReso;
386 else if (name == "change_attack") return &m_fnChangeAttack;
387 else if (name == "change_decay") return &m_fnChangeDecay;
388 else if (name == "change_release") return &m_fnChangeRelease;
389 else if (name == "change_amp_lfo_depth") return &m_fnChangeAmpLFODepth;
390 else if (name == "change_amp_lfo_freq") return &m_fnChangeAmpLFOFreq;
391 else if (name == "change_pitch_lfo_depth") return &m_fnChangePitchLFODepth;
392 else if (name == "change_pitch_lfo_freq") return &m_fnChangePitchLFOFreq;
393 else if (name == "fade_in") return &m_fnFadeIn;
394 else if (name == "fade_out") return &m_fnFadeOut;
395 else if (name == "change_vol_curve") return &m_fnChangeVolCurve;
396 else if (name == "change_tune_curve") return &m_fnChangeTuneCurve;
397 else if (name == "change_play_pos") return &m_fnChangePlayPos;
398 else if (name == "get_event_par") return &m_fnGetEventPar;
399 else if (name == "set_event_par") return &m_fnSetEventPar;
400 else if (name == "event_status") return &m_fnEventStatus;
401 else if (name == "wait") return &m_fnWait2; // override wait() core implementation
402 else if (name == "stop_wait") return &m_fnStopWait;
403
404 // built-in script functions of derived VM class
405 return ScriptVM::functionByName(name);
406 }
407
408 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC