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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3118 by schoenebeck, Fri Apr 21 13:33:03 2017 UTC revision 3563 by schoenebeck, Fri Aug 23 13:33:21 2019 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
6   *   Copyright (C) 2005 - 2017 Christian Schoenebeck                       *   *   Copyright (C) 2005 - 2019 Christian Schoenebeck                       *
7   *                                                                         *   *                                                                         *
8   *   This program is free software; you can redistribute it and/or modify  *   *   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  *   *   it under the terms of the GNU General Public License as published by  *
# Line 58  namespace LinuxSampler { Line 58  namespace LinuxSampler {
58          public:          public:
59              EventGenerator(uint SampleRate);              EventGenerator(uint SampleRate);
60              void UpdateFragmentTime(uint SamplesToProcess);              void UpdateFragmentTime(uint SamplesToProcess);
61                void SetSampleRate(uint SampleRate);
62              Event CreateEvent();              Event CreateEvent();
63              Event CreateEvent(int32_t FragmentPos);              Event CreateEvent(int32_t FragmentPos);
64    
# Line 166  namespace LinuxSampler { Line 167  namespace LinuxSampler {
167                  type_note_pressure, ///< polyphonic key pressure (aftertouch)                  type_note_pressure, ///< polyphonic key pressure (aftertouch)
168                  type_play_note, ///< caused by a call to built-in instrument script function play_note()                  type_play_note, ///< caused by a call to built-in instrument script function play_note()
169                  type_stop_note, ///< caused by a call to built-in instrument script function note_off()                  type_stop_note, ///< caused by a call to built-in instrument script function note_off()
170                    type_kill_note, ///< caused by a call to built-in instrument script function fade_out()
171                  type_note_synth_param, ///< change a note's synthesis parameters (upon real-time instrument script function calls, i.e. change_vol(), change_tune(), change_pan(), etc.)                  type_note_synth_param, ///< change a note's synthesis parameters (upon real-time instrument script function calls, i.e. change_vol(), change_tune(), change_pan(), etc.)
172              } Type;              } Type;
173              enum synth_param_t {              enum synth_param_t {
174                  synth_param_volume,                  synth_param_volume,
175                    synth_param_volume_time,
176                    synth_param_volume_curve,
177                  synth_param_pitch,                  synth_param_pitch,
178                    synth_param_pitch_time,
179                    synth_param_pitch_curve,
180                  synth_param_pan,                  synth_param_pan,
181                    synth_param_pan_time,
182                    synth_param_pan_curve,
183                  synth_param_cutoff,                  synth_param_cutoff,
184                  synth_param_resonance,                  synth_param_resonance,
185                  synth_param_attack,                  synth_param_attack,
186                  synth_param_decay,                  synth_param_decay,
187                    synth_param_sustain,
188                  synth_param_release,                  synth_param_release,
189                    synth_param_cutoff_attack,
190                    synth_param_cutoff_decay,
191                    synth_param_cutoff_sustain,
192                    synth_param_cutoff_release,
193                  synth_param_amp_lfo_depth,                  synth_param_amp_lfo_depth,
194                  synth_param_amp_lfo_freq,                  synth_param_amp_lfo_freq,
195                    synth_param_cutoff_lfo_depth,
196                    synth_param_cutoff_lfo_freq,
197                  synth_param_pitch_lfo_depth,                  synth_param_pitch_lfo_depth,
198                  synth_param_pitch_lfo_freq,                  synth_param_pitch_lfo_freq,
199              };              };
200                enum class ValueScope : unsigned char {
201                    /**
202                     * The new synthesis parameter value should be applied
203                     * relatively to itself (as normalized value range), and then
204                     * applied relatively against other sources (i.e. LFOs, EGs)
205                     * for the same synthesis parameter.
206                     */
207                    SELF_RELATIVE = 1,
208                    /**
209                     * The new synthesis paramater value of itself should be
210                     * replaced, and then applied relatively to other sources
211                     * (i.e. LFOs, EGs) for the same synthesis parameter.
212                     */
213                    RELATIVE = 0, //IMPORANT: must remain 0 because of the union structure below which would otherwise i.e. assign invalid pointers/IDs to Param.Note structure in Init()
214                    /**
215                     * The new synthesis parameter value should be applied
216                     * relatively to itself (as normalized value range), and then
217                     * applied directly (as normalized value range) as final value
218                     * of this synthesis chain, thus all other sources (i.e. LFOs,
219                     * EGs) should entirely be ignored.
220                     */
221                    FINAL_SELF_RELATIVE = 2,
222                    /**
223                     * The new synthesis parameter value of itself should be
224                     * replaced, and then applied directly (as normalized value
225                     * range) as final value of this synthesis chain, thus all other
226                     * sources (i.e. LFOs, EGs) should entirely be ignored.
227                     */
228                    FINAL_NORM = 3,
229                    /**
230                     * Same as @c FINAL_NORM, but this one is already in the native
231                     * unit (i.e. seconds, Hz) of this synthesis parameter.
232                     */
233                    FINAL_NATIVE = 4,
234                };
235              union {              union {
236                  /// Note-on and note-off event specifics                  /// Note-on and note-off event specifics
237                  struct _Note {                  struct _Note {
# Line 226  namespace LinuxSampler { Line 276  namespace LinuxSampler {
276                      note_id_t     NoteID;   ///< ID of Note whose voices shall be modified.                      note_id_t     NoteID;   ///< ID of Note whose voices shall be modified.
277                      synth_param_t Type;     ///< Synthesis parameter which is to be changed.                      synth_param_t Type;     ///< Synthesis parameter which is to be changed.
278                      float         Delta;    ///< The value change that should be applied against the note's current synthesis parameter value.                      float         Delta;    ///< The value change that should be applied against the note's current synthesis parameter value.
                     bool          Relative; ///< Whether @c Delta should be applied relatively against the note's current synthesis parameter value (false means the paramter's current value is simply replaced by Delta).  
279                      float         AbsValue; ///< New current absolute value of synthesis parameter (that is after @c Delta being applied).                      float         AbsValue; ///< New current absolute value of synthesis parameter (that is after @c Delta being applied).
280                        ValueScope    Scope;    ///< How @c Delta should be applied against @c AbsValue, and how @c AbsValue should then actually be applied to the synthesis chain.
281    
282                        inline bool isFinal() const { return Scope >= ValueScope::FINAL_SELF_RELATIVE; }
283                  } NoteSynthParam;                  } NoteSynthParam;
284              } Param;              } Param;
285              EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).              EngineChannel* pEngineChannel; ///< Pointer to the EngineChannel where this event occured on, NULL means Engine global event (e.g. SysEx message).
286              MidiInputPort* pMidiInputPort; ///< Pointer to the MIDI input port on which this event occured (NOTE: currently only for global events, that is SysEx messages)              MidiInputPort* pMidiInputPort; ///< Pointer to the MIDI input port on which this event occured (NOTE: currently only for global events, that is SysEx messages)
287    
288              inline void Init() {              inline void Init() {
289                    //FIXME: probably we should memset() zero entire structure here, due to potential union initialization conflicts (see comment on ValueScope::RELATIVE)
290                  Param.Note.ID = 0;                  Param.Note.ID = 0;
291                  Param.Note.ParentNoteID = 0;                  Param.Note.ParentNoteID = 0;
292                  Param.NoteSynthParam.NoteID = 0;                  Param.NoteSynthParam.NoteID = 0;
293                    Param.NoteSynthParam.Scope = ValueScope::RELATIVE;
294              }              }
295              inline int32_t FragmentPos() {              inline int32_t FragmentPos() {
296                  if (iFragmentPos >= 0) return iFragmentPos;                  if (iFragmentPos >= 0) return iFragmentPos;
# Line 254  namespace LinuxSampler { Line 308  namespace LinuxSampler {
308              inline sched_time_t SchedTime() {              inline sched_time_t SchedTime() {
309                  return pEventGenerator->schedTimeAtCurrentFragmentStart() + FragmentPos();                  return pEventGenerator->schedTimeAtCurrentFragmentStart() + FragmentPos();
310              }              }
311                inline static ValueScope scopeBy_FinalRelativeUnit(bool bFinal, bool bRelative, bool bNativeUnit) {
312                    if (!bFinal && bRelative)
313                        return ValueScope::SELF_RELATIVE;
314                    if (!bFinal)
315                        return ValueScope::RELATIVE;
316                    if (bRelative)
317                        return ValueScope::FINAL_SELF_RELATIVE;
318                    if (bNativeUnit)
319                        return ValueScope::FINAL_NATIVE;
320                    return ValueScope::FINAL_NORM;
321                }
322          protected:          protected:
323              typedef EventGenerator::time_stamp_t time_stamp_t;              typedef EventGenerator::time_stamp_t time_stamp_t;
324              Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);              Event(EventGenerator* pGenerator, EventGenerator::time_stamp_t Time);
# Line 303  namespace LinuxSampler { Line 368  namespace LinuxSampler {
368      class VMEventHandler;      class VMEventHandler;
369      class VMExecContext;      class VMExecContext;
370    
371        /**
372         * Maximum amount of child script handler instances one script handler is
373         * allowed to create by calling built-in script function fork().
374         */
375        #define MAX_FORK_PER_SCRIPT_HANDLER 8
376    
377      /** @brief Real-time instrument script event.      /** @brief Real-time instrument script event.
378       *       *
379       * Encapsulates one execution instance of a real-time instrument script for       * Encapsulates one execution instance of a real-time instrument script for
# Line 326  namespace LinuxSampler { Line 397  namespace LinuxSampler {
397          int executionSlices; ///< Amount of times this script event has been executed by the ScriptVM runner class.          int executionSlices; ///< Amount of times this script event has been executed by the ScriptVM runner class.
398          bool ignoreAllWaitCalls; ///< If true: calling any built-in wait*() script function should be ignored (this variable may be set with the 2nd argument of built-in script function stop_wait()).          bool ignoreAllWaitCalls; ///< If true: calling any built-in wait*() script function should be ignored (this variable may be set with the 2nd argument of built-in script function stop_wait()).
399          VMEventHandlerType_t handlerType; ///< Native representation of built-in script variable $NI_CALLBACK_TYPE, reflecting the script event type of this script event.          VMEventHandlerType_t handlerType; ///< Native representation of built-in script variable $NI_CALLBACK_TYPE, reflecting the script event type of this script event.
400            script_callback_id_t parentHandlerID; ///< Only in case this script handler instance was created by calling built-in script function fork(): callback ID of the parent event handler instance which created this child. For regular event handler instances which were not created by fork(), this variable reflects 0 (which is always considered an invalid handler ID).
401            script_callback_id_t childHandlerID[MAX_FORK_PER_SCRIPT_HANDLER+1]; ///< In case built-in script function fork() was called by this script handler instance: A zero terminated ID list of all child event handler instances (note: children will not vanish from this list after they terminated).
402            bool autoAbortByParent; ///< Only if this is a child event handler created by calling fork(): if this is true then this child will automatically aborted if the parent event handler terminates.
403            int forkIndex; ///< Only for fork() calls: distinguishment feature which is 0 for parent, 1 for 1st child, 2 for 2nd child, etc.
404    
405            void forkTo(ScriptEvent* e, bool bAutoAbort) const;
406            int countChildHandlers() const;
407            void addChildHandlerID(script_callback_id_t childID);
408      };      };
409    
410      /**      /**
# Line 337  namespace LinuxSampler { Line 416  namespace LinuxSampler {
416       * interpreted by this method to be "now".       * interpreted by this method to be "now".
417       *       *
418       * The meaning of @a fragmentPosBase becomes more important the larger       * The meaning of @a fragmentPosBase becomes more important the larger
419       * the audio fragment size, and vice versa it bcomes less important the       * the audio fragment size, and vice versa it becomes less important the
420       * smaller the audio fragment size.       * smaller the audio fragment size.
421       *       *
422       * @param queue - destination scheduler queue       * @param queue - destination scheduler queue
# Line 347  namespace LinuxSampler { Line 426  namespace LinuxSampler {
426       */       */
427      template<typename T>      template<typename T>
428      void EventGenerator::scheduleAheadMicroSec(RTAVLTree<T>& queue, T& node, int32_t fragmentPosBase, uint64_t microseconds) {      void EventGenerator::scheduleAheadMicroSec(RTAVLTree<T>& queue, T& node, int32_t fragmentPosBase, uint64_t microseconds) {
429          node.scheduleTime = uiTotalSamplesProcessed + fragmentPosBase + float(uiSampleRate) * (float(microseconds) / 1000000.f);          // round up (+1) if microseconds is not zero (i.e. because 44.1 kHz and
430            // 1 us would yield in < 1 and thus would be offset == 0)
431            const sched_time_t offset =
432                (microseconds != 0LL) ?
433                    1.f + (float(uiSampleRate) * (float(microseconds) / 1000000.f))
434                    : 0.f;
435            node.scheduleTime = uiTotalSamplesProcessed + fragmentPosBase + offset;
436          queue.insert(node);          queue.insert(node);
437      }      }
438    
Legend:
Removed from v.3118  
changed lines
  Added in v.3563
  ViewVC Help
Powered by ViewVC