/[svn]/linuxsampler/trunk/src/engines/EngineBase.h

Diff of /linuxsampler/trunk/src/engines/EngineBase.h

Parent Directory | Revision Log | View Patch Patch

-revision 2871 by schoenebeck,
Sun Apr 10 18:22:23 2016 UTC
+revision 3690 by schoenebeck,
Fri Jan  3 10:18:21 2020 UTC
 Line 5
   *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
   *   Copyright (C) 2005-2008 Christian Schoenebeck                         *
   *   Copyright (C) 2009-2012 Christian Schoenebeck and Grigor Iliev        *
-  *   Copyright (C) 2012-2016 Christian Schoenebeck and Andreas Persson     *
+  *   Copyright (C) 2012-2017 Christian Schoenebeck and Andreas Persson     *
   *                                                                         *
   *   This program is free software; you can redistribute it and/or modify  *
   *   it under the terms of the GNU General Public License as published by  *
 Line 33
  #include "InstrumentManager.h"
  #include "../common/global_private.h"
+ // a bit headroom over CONFIG_MAX_VOICES to avoid minor complications i.e. under voice stealing conditions
+ #define MAX_NOTES_HEADROOM  3
+ #define GLOBAL_MAX_NOTES    (GLOBAL_MAX_VOICES * MAX_NOTES_HEADROOM)
  namespace LinuxSampler {
-Line 46 
 namespace LinuxSampler {
+Line 49 
 namespace LinuxSampler {
          class IM  /* Instrument Manager */,
          class I   /* Instrument */
      >
-     class EngineBase: public AbstractEngine, public RegionPools<R>, public VoicePool<V> {
+     class EngineBase: public AbstractEngine, public RegionPools<R>, public NotePool<V> {
          public:
+             typedef typename RTList< Note<V> >::Iterator NoteIterator;
              typedef typename RTList<V>::Iterator VoiceIterator;
              typedef typename Pool<V>::Iterator PoolVoiceIterator;
              typedef typename RTList<RR*>::Iterator RootRegionIterator;
              typedef typename MidiKeyboardManager<V>::MidiKey MidiKey;
-             EngineBase() : SuspendedRegions(128) {
+             EngineBase() : noteIDPool(GLOBAL_MAX_NOTES), SuspendedRegions(128) {
                  pDiskThread          = NULL;
+                 pNotePool            = new Pool< Note<V> >(GLOBAL_MAX_NOTES);
+                 pNotePool->setPoolElementIDsReservedBits(INSTR_SCRIPT_EVENT_ID_RESERVED_BITS);
                  pVoicePool           = new Pool<V>(GLOBAL_MAX_VOICES);
                  pRegionPool[0]       = new Pool<R*>(GLOBAL_MAX_VOICES);
                  pRegionPool[1]       = new Pool<R*>(GLOBAL_MAX_VOICES);
                  pVoiceStealingQueue  = new RTList<Event>(pEventPool);
                  iMaxDiskStreams      = GLOBAL_MAX_STREAMS;
-                 for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
+                 // init all Voice objects in voice pool
+                 for (VoiceIterator iterVoice = pVoicePool->allocAppend();
+                      iterVoice; iterVoice = pVoicePool->allocAppend())
+                 {
                      iterVoice->SetEngine(this);
                  }
                  pVoicePool->clear();
+                 // init all Note objects in note pool
+                 for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
+                      itNote = pNotePool->allocAppend())
+                 {
+                     itNote->init(pVoicePool, &noteIDPool);
+                 }
+                 pNotePool->clear();
                  ResetInternal();
                  ResetScaleTuning();
                  ResetSuspendedRegions();
-Line 80 
 namespace LinuxSampler {
+Line 97 
 namespace LinuxSampler {
                      dmsg(1,("OK\n"));
                  }
+                 if (pNotePool) {
+                     pNotePool->clear();
+                     delete pNotePool;
+                 }
                  if (pVoicePool) {
                      pVoicePool->clear();
                      delete pVoicePool;
-Line 141 
 namespace LinuxSampler {
+Line 163 
 namespace LinuxSampler {
                                  dmsg(5,("Engine: Sysex received\n"));
                                  ProcessSysex(itEvent);
                                  break;
+                             default: ; // noop
                          }
                      }
                  }
-Line 179 
 namespace LinuxSampler {
+Line 202 
 namespace LinuxSampler {
                      PostProcess(engineChannels[i]);
                  }
+                 // Just for debugging: dump the amount of free Note objects to
+                 // the terminal (note due to the static variables being used,
+                 // this is currently just intended for debugging with only one
+                 // engine channel).
+                 #if (CONFIG_DEBUG_LEVEL >= 3)
+                 {
+                     static int slice = 0;
+                     static int noteCount = -1;
+                     if (slice++ % 10 == 0) {
+                         int n = pNotePool->countFreeElements();
+                         if (n != noteCount) {
+                             noteCount = n;
+                             dmsg(1,("[%d] free Note objects count = %d\n", slice / 10, n));
+                         }
+                     }
+                 }
+                 #endif
                  // empty the engine's event list for the next audio fragment
                  ClearEventLists();
-Line 236 
 namespace LinuxSampler {
+Line 276 
 namespace LinuxSampler {
                      pChannel->ResetRegionsInUse(pRegionPool);
                  }
+                 // FIXME: Shouldn't all those pool elements be freed before resizing the pools?
                  try {
                      pVoicePool->resizePool(iVoices);
+                     pNotePool->resizePool(iVoices * MAX_NOTES_HEADROOM);
+                     noteIDPool.resizePool(iVoices * MAX_NOTES_HEADROOM);
                  } catch (...) {
                      throw Exception("FATAL: Could not resize voice pool!");
                  }
-                 for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
+                 for (VoiceIterator iterVoice = pVoicePool->allocAppend();
+                      iterVoice; iterVoice = pVoicePool->allocAppend())
+                 {
                      iterVoice->SetEngine(this);
                      iterVoice->pDiskThread = this->pDiskThread;
                  }
                  pVoicePool->clear();
+                 for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
+                      itNote = pNotePool->allocAppend())
+                 {
+                     itNote->init(pVoicePool, &noteIDPool);
+                 }
+                 pNotePool->clear();
                  PostSetMaxVoices(iVoices);
                  ResumeAll();
              }
-Line 316 
 namespace LinuxSampler {
+Line 368 
 namespace LinuxSampler {
                      MinFadeOutSamples = MaxSamplesPerCycle;
                      // lower minimum release time
                      const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;
+                     pVoicePool->clear();
                      for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
                          iterVoice->CalculateFadeOutCoeff(minReleaseTime, SampleRate);
                      }
-Line 336 
 namespace LinuxSampler {
+Line 389 
 namespace LinuxSampler {
                      exit(EXIT_FAILURE);
                  }
+                 pVoicePool->clear();
                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
                      iterVoice->pDiskThread = this->pDiskThread;
                      dmsg(3,("d"));
                  }
                  pVoicePool->clear();
-                 // (re)create event generator
+                 // update event generator
-                 if (pEventGenerator) delete pEventGenerator;
+                 pEventGenerator->SetSampleRate(pAudioOut->SampleRate());
-                 pEventGenerator = new EventGenerator(pAudioOut->SampleRate());
                  dmsg(1,("Starting disk thread..."));
                  pDiskThread->StartThread();
-Line 560 
 namespace LinuxSampler {
+Line 613 
 namespace LinuxSampler {
              }
              // implementation of abstract method derived from class 'LinuxSampler::RegionPools'
-             virtual Pool<R*>* GetRegionPool(int index) {
+             virtual Pool<R*>* GetRegionPool(int index) OVERRIDE {
                  if (index < 0 || index > 1) throw Exception("Index out of bounds");
                  return pRegionPool[index];
              }
-             // implementation of abstract method derived from class 'LinuxSampler::VoicePool'
+             // implementation of abstract methods derived from class 'LinuxSampler::NotePool'
-             virtual Pool<V>* GetVoicePool() { return pVoicePool; }
+             virtual Pool<V>* GetVoicePool() OVERRIDE { return pVoicePool; }
+             virtual Pool< Note<V> >* GetNotePool() OVERRIDE { return pNotePool; }
+             virtual Pool<note_id_t>* GetNoteIDPool() OVERRIDE { return &noteIDPool; }
              D* GetDiskThread() { return pDiskThread; }
-Line 586 
 namespace LinuxSampler {
+Line 641 
 namespace LinuxSampler {
                  }
                  virtual bool Process(MidiKey* pMidiKey) OVERRIDE {
-                     VoiceIterator itVoice = pMidiKey->pActiveVoices->first();
+                     NoteIterator  itNote  = pMidiKey->pActiveNotes->first();
+                     VoiceIterator itVoice = itNote->pActiveVoices->first();
                      // if current key is not associated with this region, skip this key
                      if (itVoice->GetRegion()->GetParent() != pPendingRegionSuspension) return false;
-Line 609 
 namespace LinuxSampler {
+Line 665 
 namespace LinuxSampler {
              int                          ActiveVoiceCountTemp;  ///< number of currently active voices (for internal usage, will be used for incrementation)
              VoiceIterator                itLastStolenVoice;     ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
+             NoteIterator                 itLastStolenNote;      ///< Only for voice stealing: points to the last note from which was theft in current audio fragment, NULL otherwise.
              RTList<uint>::Iterator       iuiLastStolenKey;      ///< Only for voice stealing: key number of last key on which the last voice was theft in current audio fragment, NULL otherwise.
              EngineChannelBase<V, R, I>*  pLastStolenChannel;    ///< Only for voice stealing: points to the engine channel on which the previous voice was stolen in this audio fragment.
              VoiceIterator                itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
+             NoteIterator                 itLastStolenNoteGlobally; ///< Same as itLastStolenNote, but engine globally
              RTList<uint>::Iterator       iuiLastStolenKeyGlobally;  ///< Same as iuiLastStolenKey, but engine globally
              RTList<Event>*               pVoiceStealingQueue;   ///< All voice-launching events which had to be postponed due to free voice shortage.
              Mutex                        ResetInternalMutex;    ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads).
              int iMaxDiskStreams;
+             NoteBase* NoteByID(note_id_t id) OVERRIDE {
+                 NoteIterator itNote = GetNotePool()->fromID(id);
+                 if (!itNote) return NULL;
+                 return &*itNote;
+             }
+             /**
+              * Gets a new @c Note object from the note pool, initializes it
+              * appropriately, links it with requested parent note (if
+              * requested), moves it to the appropriate key's list of active
+              * notes it, and sticks the new note's unique ID to the
+              * passed @a pNoteOnEvent.
+              *
+              * @param pEngineChannel - engine channel on which this event happened
+              * @param pNoteOnEvent - event which caused this
+              * @returns new note's unique ID (or zero on error)
+              */
+             note_id_t LaunchNewNote(LinuxSampler::EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) OVERRIDE {
+                 EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 Pool< Note<V> >* pNotePool = GetNotePool();
+                 if (pNotePool->poolIsEmpty()) {
+                     dmsg(1,("Engine: Could not launch new note; Note pool empty!\n"));
+                     return 0; // error
+                 }
+                 // create a new note (for new voices to be assigned to)
+                 //NoteIterator itNewNote = pKey->pActiveNotes->allocAppend();
+                 NoteIterator itNewNote = pNotePool->allocAppend();
+                 const note_id_t newNoteID = pNotePool->getID(itNewNote);
+                 // remember the engine's time when this note was triggered exactly
+                 itNewNote->triggerSchedTime = itNoteOnEvent->SchedTime();
+                 // usually the new note (and its subsequent voices) will be
+                 // allocated on the key provided by the event's note number,
+                 // however if this new note is requested not to be a regular
+                 // note, but rather a child note, then this new note will be
+                 // allocated on the parent note's key instead in order to
+                 // release the child note simultaniously with its parent note
+                 itNewNote->hostKey = itNoteOnEvent->Param.Note.Key;
+                 // in case this new note was requested to be a child note,
+                 // then retrieve its parent note and link them with each other
+                 const note_id_t parentNoteID = itNoteOnEvent->Param.Note.ParentNoteID;
+                 if (parentNoteID) {
+                     NoteIterator itParentNote = pNotePool->fromID(parentNoteID);
+                     if (itParentNote) {
+                         RTList<note_id_t>::Iterator itChildNoteID = itParentNote->pChildNotes->allocAppend();
+                         if (itChildNoteID) {
+                             // link parent and child note with each other
+                             *itChildNoteID = newNoteID;
+                             itNewNote->parentNoteID = parentNoteID;
+                             itNewNote->hostKey = itParentNote->hostKey;
+                         } else {
+                             dmsg(1,("Engine: Could not assign new note as child note; Note ID pool empty!\n"));
+                             pNotePool->free(itNewNote);
+                             return 0; // error
+                         }
+                     } else {
+                         // the parent note was apparently released already, so
+                         // free the new note again and inform caller that it
+                         // should drop the event
+                         dmsg(3,("Engine: Could not assign new note as child note; Parent note is gone!\n"));
+                         pNotePool->free(itNewNote);
+                         return 0; // error
+                     }
+                 }
+                 dmsg(2,("Launched new note on host key %d\n", itNewNote->hostKey));
+                 // copy event which caused this note
+                 itNewNote->cause = *itNoteOnEvent;
+                 itNewNote->eventID = pEventPool->getID(itNoteOnEvent);
+                 if (!itNewNote->eventID) {
+                     dmsg(0,("Engine: No valid event ID resolved for note. This is a bug!!!\n"));
+                 }
+                 // move new note to its host key
+                 MidiKey* pKey = &pChannel->pMIDIKeyInfo[itNewNote->hostKey];
+                 itNewNote.moveToEndOf(pKey->pActiveNotes);
+                 pChannel->markKeyAsActive(pKey);
+                 // assign unique note ID of this new note to the original note on event
+                 itNoteOnEvent->Param.Note.ID = newNoteID;
+                 return newNoteID; // success
+             }
              /**
               * Dispatch and handle all events in this audio fragment for the given
               * engine channel.
-Line 648 
 namespace LinuxSampler {
+Line 795 
 namespace LinuxSampler {
                      //
                      // FIXME: it would probably be better to just schedule newly spawned script executions here and then execute them altogether with already suspended ones all at once in order of all their scheduled timing
                      for (RTList<Event>::Iterator itEvent = pChannel->pEvents->first(),
-                         end = pChannel->pEvents->end(); itEvent != end; ++itEvent)
+                         end = pChannel->pEvents->end(); itEvent != end; )
                      {
+                         //HACK: avoids iterator invalidation which might happen below since an instrument script might drop an event by direct raw pointer access (it would be considerable to extend the Iterator class to detect and circumvent this case by checking the "reincarnation" member variable).
+                         RTList<Event>::Iterator itNext = itEvent;
+                         ++itNext;
                          switch (itEvent->Type) {
                              case Event::type_note_on:
                                  if (pChannel->pScript->handlerNote)
-Line 668 
 namespace LinuxSampler {
+Line 819 
 namespace LinuxSampler {
                              case Event::type_note_pressure:
                                  //TODO: ...
                                  break;
+                             case Event::type_sysex:
+                                 //TODO: ...
+                                 break;
+                             case Event::type_cancel_release_key:
+                             case Event::type_release_key:
+                             case Event::type_release_note:
+                             case Event::type_play_note:
+                             case Event::type_stop_note:
+                             case Event::type_kill_note:
+                             case Event::type_note_synth_param:
+                                 break; // noop
                          }
+                         // see HACK comment above
+                         itEvent = itNext;
                      }
                      // this has to be run again, since the newly spawned scripts
-Line 723 
 namespace LinuxSampler {
+Line 890 
 namespace LinuxSampler {
                                  dmsg(5,("Engine: Note on received\n"));
                                  ProcessNoteOn((EngineChannel*)itEvent->pEngineChannel, itEvent);
                                  break;
+                             case Event::type_play_note:
+                                 dmsg(5,("Engine: Play Note received\n"));
+                                 ProcessNoteOn((EngineChannel*)itEvent->pEngineChannel, itEvent);
+                                 break;
                              case Event::type_note_off:
                                  dmsg(5,("Engine: Note off received\n"));
                                  ProcessNoteOff((EngineChannel*)itEvent->pEngineChannel, itEvent);
                                  break;
+                             case Event::type_stop_note:
+                                 dmsg(5,("Engine: Stop Note received\n"));
+                                 ProcessNoteOff((EngineChannel*)itEvent->pEngineChannel, itEvent);
+                                 break;
+                             case Event::type_kill_note:
+                                 dmsg(5,("Engine: Kill Note received\n"));
+                                 ProcessKillNote((EngineChannel*)itEvent->pEngineChannel, itEvent);
+                                 break;
                              case Event::type_control_change:
                                  dmsg(5,("Engine: MIDI CC received\n"));
                                  ProcessControlChange((EngineChannel*)itEvent->pEngineChannel, itEvent);
-Line 743 
 namespace LinuxSampler {
+Line 922 
 namespace LinuxSampler {
                                  dmsg(5,("Engine: Pitchbend received\n"));
                                  ProcessPitchbend(static_cast<AbstractEngineChannel*>(itEvent->pEngineChannel), itEvent);
                                  break;
+                             case Event::type_note_synth_param:
+                                 dmsg(5,("Engine: Note Synth Param received\n"));
+                                 ProcessNoteSynthParam(itEvent->pEngineChannel, itEvent);
+                                 break;
+                             case Event::type_sysex:
+                                 break; // TODO ...
+                             case Event::type_cancel_release_key:
+                             case Event::type_release_key:
+                             case Event::type_release_note:
+                                 break; // noop
                          }
                      }
                  }
-Line 750 
 namespace LinuxSampler {
+Line 940 
 namespace LinuxSampler {
                  // reset voice stealing for the next engine channel (or next audio fragment)
                  itLastStolenVoice         = VoiceIterator();
                  itLastStolenVoiceGlobally = VoiceIterator();
+                 itLastStolenNote          = NoteIterator();
+                 itLastStolenNoteGlobally  = NoteIterator();
                  iuiLastStolenKey          = RTList<uint>::Iterator();
                  iuiLastStolenKeyGlobally  = RTList<uint>::Iterator();
                  pLastStolenChannel        = NULL;
-Line 809 
 namespace LinuxSampler {
+Line 1001 
 namespace LinuxSampler {
                      // script event object
                      RTList<ScriptEvent>::Iterator itScriptEvent =
                          pChannel->pScript->pEvents->allocAppend();
+                     // if event handler uses polyphonic variables, reset them
+                     // to zero values before starting to execute the handler
+                     if (pEventHandler->isPolyphonic())
+                         itScriptEvent->execCtx->resetPolyphonicData();
                      ProcessScriptEvent(
                          pChannel, itEvent, pEventHandler, itScriptEvent
                      );
-Line 841 
 namespace LinuxSampler {
+Line 1037 
 namespace LinuxSampler {
                  // initialize/reset other members
                  itScriptEvent->cause = *itEvent;
-                 itScriptEvent->id = pEventPool->getID(itEvent);
+                 itScriptEvent->scheduleTime = itEvent->SchedTime();
                  itScriptEvent->currentHandler = 0;
                  itScriptEvent->executionSlices = 0;
+                 itScriptEvent->ignoreAllWaitCalls = false;
+                 itScriptEvent->handlerType = pEventHandler->eventHandlerType();
+                 itScriptEvent->parentHandlerID = 0;
+                 itScriptEvent->childHandlerID[0] = 0;
+                 itScriptEvent->autoAbortByParent = false;
+                 itScriptEvent->forkIndex = 0;
+                 // this is the native representation of the $EVENT_ID script variable
+                 itScriptEvent->id =
+                     (itEvent->Type == Event::type_note_on)
+                         ? ScriptID::fromNoteID( itEvent->Param.Note.ID )
+                         : ScriptID::fromEventID( pEventPool->getID(itEvent) );
                  // run script handler(s)
                  VMExecStatus_t res = pScriptVM->exec(
-Line 886 
 namespace LinuxSampler {
+Line 1093 
 namespace LinuxSampler {
              /** @brief Resume execution of instrument script.
               *
               * Will be called to resume execution of a real-time instrument
-              * script event which has been suspended in a previous audio
+              * script event which has been suspended previously.
-              * fragment cycle.
               *
               * Script execution might be suspended for various reasons. Usually
               * a script will be suspended if the script called the built-in
-Line 951 
 namespace LinuxSampler {
+Line 1157 
 namespace LinuxSampler {
               *  @param itNoteOnEvent - key, velocity and time stamp of the event
               *  @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing
               */
-             int  StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
+             int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
+                 dmsg(3,("StealVoice()\n"));
                  if (VoiceSpawnsLeft <= 0) {
                      dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));
                      return -1;
-Line 959 
 namespace LinuxSampler {
+Line 1166 
 namespace LinuxSampler {
                  EngineChannelBase<V, R, I>* pEngineChn = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
-                 if (!pEventPool->poolIsEmpty()) {
+                 if (pEventPool->poolIsEmpty()) {
+                     dmsg(1,("Event pool emtpy!\n"));
+                     return -1;
+                 }
-                     if(!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &iuiLastStolenKey)) {
+                 if (!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &itLastStolenNote, &iuiLastStolenKey)) {
-                         --VoiceSpawnsLeft;
+                     --VoiceSpawnsLeft;
-                         return 0;
+                     return 0;
-                     }
+                 }
-                     // if we couldn't steal a voice from the same engine channel then
+                 // if we couldn't steal a voice from the same engine channel then
-                     // steal oldest voice on the oldest key from any other engine channel
+                 // steal oldest voice on the oldest key from any other engine channel
-                     // (the smaller engine channel number, the higher priority)
+                 // (the smaller engine channel number, the higher priority)
-                     EngineChannelBase<V, R, I>*  pSelectedChannel;
+                 EngineChannelBase<V, R, I>*  pSelectedChannel;
-                     int                       iChannelIndex;
+                 int                          iChannelIndex;
-                     VoiceIterator             itSelectedVoice;
+                 VoiceIterator                itSelectedVoice;
-                     // select engine channel
-                     if (pLastStolenChannel) {
-                         pSelectedChannel = pLastStolenChannel;
-                         iChannelIndex    = pSelectedChannel->iEngineIndexSelf;
-                     } else { // pick the engine channel followed by this engine channel
-                         iChannelIndex    = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();
-                         pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
-                     }
-                     // if we already stole in this fragment, try to proceed on same key
-                     if (this->itLastStolenVoiceGlobally) {
-                         itSelectedVoice = this->itLastStolenVoiceGlobally;
-                         do {
-                             ++itSelectedVoice;
-                         } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
-                     }
-                     #if CONFIG_DEVMODE
+                 #if CONFIG_DEVMODE
-                     EngineChannel* pBegin = pSelectedChannel; // to detect endless loop
+                 EngineChannel* pBegin = NULL; // to detect endless loop
-                     #endif // CONFIG_DEVMODE
+                 #endif
+                 // select engine channel
+                 if (pLastStolenChannel) {
+                     pSelectedChannel = pLastStolenChannel;
+                     iChannelIndex    = pSelectedChannel->iEngineIndexSelf;
+                 } else { // pick the engine channel followed by this engine channel
+                     iChannelIndex    = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();
+                     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
+                 }
+                 // if we already stole in this fragment, try to proceed on same note
+                 if (this->itLastStolenVoiceGlobally) {
+                     itSelectedVoice = this->itLastStolenVoiceGlobally;
+                     do {
+                         ++itSelectedVoice;
+                     } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
+                 }
+                 // did we find a 'stealable' voice?
+                 if (itSelectedVoice && itSelectedVoice->IsStealable()) {
+                     // remember which voice we stole, so we can simply proceed on next voice stealing
+                     this->itLastStolenVoiceGlobally = itSelectedVoice;
+                     // done
+                     goto stealable_voice_found;
+                 }
+                 // get (next) oldest note
+                 if (this->itLastStolenNoteGlobally) {
+                     for (NoteIterator itNote = ++this->itLastStolenNoteGlobally;
+                          itNote; ++itNote)
+                     {
+                         for (itSelectedVoice = itNote->pActiveVoices->first(); itSelectedVoice; ++itSelectedVoice) {
+                             // proceed iterating if voice was created in this audio fragment cycle
+                             if (itSelectedVoice->IsStealable()) {
+                                 // remember which voice of which note we stole, so we can simply proceed on next voice stealing
+                                 this->itLastStolenNoteGlobally  = itNote;
+                                 this->itLastStolenVoiceGlobally = itSelectedVoice;
+                                 goto stealable_voice_found; // selection succeeded
+                             }
+                         }
+                     }
+                 }
-                     // did we find a 'stealable' voice?
+                 #if CONFIG_DEVMODE
-                     if (itSelectedVoice && itSelectedVoice->IsStealable()) {
+                 pBegin = pSelectedChannel; // to detect endless loop
-                         // remember which voice we stole, so we can simply proceed on next voice stealing
+                 #endif // CONFIG_DEVMODE
-                         this->itLastStolenVoiceGlobally = itSelectedVoice;
-                     } else while (true) { // iterate through engine channels
+                 while (true) { // iterate through engine channels
-                         // get (next) oldest key
+                     // get (next) oldest key
-                         RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
+                     RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
-                         this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
+                     this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
-                         while (iuiSelectedKey) {
+                     while (iuiSelectedKey) {
-                             MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
+                         MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
-                             itSelectedVoice = pSelectedKey->pActiveVoices->first();
+                         for (NoteIterator itNote = pSelectedKey->pActiveNotes->first(),
+                              itNotesEnd = pSelectedKey->pActiveNotes->end();
+                              itNote != itNotesEnd; ++itNote)
+                         {
+                             itSelectedVoice = itNote->pActiveVoices->first();
                              // proceed iterating if voice was created in this fragment cycle
                              while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
                              // found a "stealable" voice ?
                              if (itSelectedVoice && itSelectedVoice->IsStealable()) {
-                                 // remember which voice on which key on which engine channel we stole, so we can simply proceed on next voice stealing
+                                 // remember which voice of which note on which key on which engine channel we stole, so we can simply proceed on next voice stealing
                                  this->iuiLastStolenKeyGlobally  = iuiSelectedKey;
+                                 this->itLastStolenNoteGlobally  = itNote;
                                  this->itLastStolenVoiceGlobally = itSelectedVoice;
                                  this->pLastStolenChannel        = pSelectedChannel;
                                  goto stealable_voice_found; // selection succeeded
                              }
-                             ++iuiSelectedKey; // get next key on current engine channel
                          }
-                         // get next engine channel
+                         ++iuiSelectedKey; // get next key on current engine channel
-                         iChannelIndex    = (iChannelIndex + 1) % engineChannels.size();
-                         pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
-                         #if CONFIG_DEVMODE
-                         if (pSelectedChannel == pBegin) {
-                             dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
-                             dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
-                             dmsg(1,("Exiting.\n"));
-                             exit(-1);
-                         }
-                         #endif // CONFIG_DEVMODE
                      }
+                     // get next engine channel
-                     // jump point if a 'stealable' voice was found
+                     iChannelIndex    = (iChannelIndex + 1) % engineChannels.size();
-                     stealable_voice_found:
+                     pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
                      #if CONFIG_DEVMODE
-                     if (!itSelectedVoice->IsActive()) {
+                     if (pSelectedChannel == pBegin) {
-                         dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));
+                         dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
-                         return -1;
+                         dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
+                         dmsg(1,("Exiting.\n"));
+                         exit(-1);
                      }
                      #endif // CONFIG_DEVMODE
+                 }
-                     // now kill the selected voice
+                 // jump point if a 'stealable' voice was found
-                     itSelectedVoice->Kill(itNoteOnEvent);
+                 stealable_voice_found:
-                     --VoiceSpawnsLeft;
-                     return 0; // success
+                 #if CONFIG_DEVMODE
-                 }
+                 if (!itSelectedVoice->IsActive()) {
-                 else {
+                     dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));
-                     dmsg(1,("Event pool emtpy!\n"));
                      return -1;
                  }
+                 #endif // CONFIG_DEVMODE
+                 // now kill the selected voice
+                 itSelectedVoice->Kill(itNoteOnEvent);
+                 --VoiceSpawnsLeft;
+                 return 0; // success
              }
              void HandleInstrumentChanges() {
-Line 1082 
 namespace LinuxSampler {
+Line 1318 
 namespace LinuxSampler {
                          // the script's "init" event handler is only executed
                          // once (when the script is loaded or reloaded)
                          if (pEngineChannel->pScript && pEngineChannel->pScript->handlerInit) {
+                             dmsg(5,("Engine: exec handlerInit %p\n", pEngineChannel->pScript->handlerInit));
                              RTList<ScriptEvent>::Iterator itScriptEvent =
                                  pEngineChannel->pScript->pEvents->allocAppend();
+                             itScriptEvent->cause = pEventGenerator->CreateEvent(0);
+                             itScriptEvent->cause.Type = (Event::type_t) -1; // some invalid type to avoid random event processing
                              itScriptEvent->cause.pEngineChannel = pEngineChannel;
+                             itScriptEvent->cause.pMidiInputPort = pEngineChannel->GetMidiInputPort();
+                             itScriptEvent->id = 0;
                              itScriptEvent->handlers[0] = pEngineChannel->pScript->handlerInit;
                              itScriptEvent->handlers[1] = NULL;
+                             itScriptEvent->currentHandler = 0;
-                             VMExecStatus_t res = pScriptVM->exec(
+                             itScriptEvent->executionSlices = 0;
-                                 pEngineChannel->pScript->parserContext, &*itScriptEvent
+                             itScriptEvent->ignoreAllWaitCalls = false;
-                             );
+                             itScriptEvent->handlerType = VM_EVENT_HANDLER_INIT;
+                             itScriptEvent->parentHandlerID = 0;
+                             itScriptEvent->childHandlerID[0] = 0;
+                             itScriptEvent->autoAbortByParent = false;
+                             itScriptEvent->forkIndex = 0;
+                             VMExecStatus_t res;
+                             size_t instructionsCount = 0;
+                             const size_t maxInstructions = 200000; // aiming approx. 1 second max. (based on very roughly 5us / instruction)
+                             bool bWarningShown = false;
+                             do {
+                                 res = pScriptVM->exec(
+                                     pEngineChannel->pScript->parserContext, &*itScriptEvent
+                                 );
+                                 instructionsCount += itScriptEvent->execCtx->instructionsPerformed();
+                                 if (instructionsCount > maxInstructions && !bWarningShown) {
+                                     bWarningShown = true;
+                                     dmsg(0,("[ScriptVM] WARNING: \"init\" event handler of instrument script executing for long time!\n"));
+                                 }
+                             } while (res & VM_EXEC_SUSPENDED && !(res & VM_EXEC_ERROR));
                              pEngineChannel->pScript->pEvents->free(itScriptEvent);
                          }
-Line 1145 
 namespace LinuxSampler {
+Line 1405 
 namespace LinuxSampler {
                      EngineChannelBase<V, R, I>* pEngineChannel =
                          static_cast<EngineChannelBase<V, R, I>*>(itVoiceStealEvent->pEngineChannel);;
                      if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded
                      PoolVoiceIterator itNewVoice =
                          LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);
                      if (itNewVoice) {
+                         // usually there should already be a new Note object
+                         NoteIterator itNote = GetNotePool()->fromID(itVoiceStealEvent->Param.Note.ID);
+                         if (!itNote) { // should not happen, but just to be sure ...
+                             dmsg(2,("Engine: No Note object for stolen voice!\n"));
+                             const note_id_t noteID = LaunchNewNote(pEngineChannel, itVoiceStealEvent);
+                             if (!noteID) {
+                                 dmsg(1,("Engine: Voice stealing failed; No Note object and Note pool empty!\n"));
+                                 continue;
+                             }
+                             itNote = GetNotePool()->fromID(noteID);
+                         }
+                         // move voice from whereever it was, to the new note's list of active voices
+                         itNewVoice = itNewVoice.moveToEndOf(itNote->pActiveVoices);
+                         // render audio of this new voice for the first time
                          itNewVoice->Render(Samples);
                          if (itNewVoice->IsActive()) { // still active
                              *(pEngineChannel->pRegionsInUse->allocAppend()) = itNewVoice->GetRegion();
-Line 1182 
 namespace LinuxSampler {
+Line 1457 
 namespace LinuxSampler {
              void PostProcess(EngineChannel* pEngineChannel) {
                  EngineChannelBase<V, R, I>* pChannel =
                      static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
-                  pChannel->FreeAllInactiveKyes();
+                  pChannel->FreeAllInactiveKeys();
                  // empty the engine channel's own event lists
                  // (only events of the current audio fragment cycle)
-Line 1209 
 namespace LinuxSampler {
+Line 1484 
 namespace LinuxSampler {
                          pChannel->PortamentoTime = (float) itControlChangeEvent->Param.CC.Value / 127.0f * (float) CONFIG_PORTAMENTO_TIME_MAX + (float) CONFIG_PORTAMENTO_TIME_MIN;
                          break;
                      }
-                     case 6: { // data entry (currently only used for RPN and NRPN controllers)
+                     case 6: { // data entry (MSB)
-                         //dmsg(1,("DATA ENTRY %d\n", itControlChangeEvent->Param.CC.Value));
+                         //dmsg(1,("DATA ENTRY MSB %d\n", itControlChangeEvent->Param.CC.Value));
-                         if (pChannel->GetMidiRpnController() >= 0) { // RPN controller number was sent previously ...
-                             dmsg(4,("Guess it's an RPN ...\n"));
+                         // look-ahead: if next MIDI event is data entry LSB,
-                             if (pChannel->GetMidiRpnController() == 2) { // coarse tuning in half tones
+                         // then skip this event here for now (to avoid double
-                                 int transpose = (int) itControlChangeEvent->Param.CC.Value - 64;
+                         // handling of what's supposed to be one RPN/NRPN event)
-                                 // limit to +- two octaves for now
+                         if (isNextEventCCNr(itControlChangeEvent, 38))
-                                 transpose = RTMath::Min(transpose,  24);
+                             break;
-                                 transpose = RTMath::Max(transpose, -24);
-                                 pChannel->GlobalTranspose = transpose;
+                         if (pChannel->GetMidiRpnParameter() >= 0) { // RPN parameter number was sent previously ...
-                                 // workaround, so we won't have hanging notes
+                             int ch = itControlChangeEvent->Param.CC.Channel;
-                                 pChannel->ReleaseAllVoices(itControlChangeEvent);
+                             int param = pChannel->GetMidiRpnParameter();
-                             }
+                             int value = itControlChangeEvent->Param.CC.Value << 7;
-                             // to prevent other MIDI CC #6 messages to be misenterpreted as RPN controller data
-                             pChannel->ResetMidiRpnController();
+                             // transform event type: CC event -> RPN event
-                         } else if (pChannel->GetMidiNrpnController() >= 0) { // NRPN controller number was sent previously ...
+                             itControlChangeEvent->Type = Event::type_rpn;
-                             dmsg(4,("Guess it's an NRPN ...\n"));
+                             itControlChangeEvent->Param.RPN.Channel = ch;
-                             const int NrpnCtrlMSB = pChannel->GetMidiNrpnController() >> 8;
+                             itControlChangeEvent->Param.RPN.Parameter = param;
-                             const int NrpnCtrlLSB = pChannel->GetMidiNrpnController() & 0xff;
+                             itControlChangeEvent->Param.RPN.Value = value;
-                             dmsg(4,("NRPN MSB=%d LSB=%d Data=%d\n", NrpnCtrlMSB, NrpnCtrlLSB, itControlChangeEvent->Param.CC.Value));
-                             switch (NrpnCtrlMSB) {
+                             // if there's a RPN script handler, run it ...
-                                 case 0x1a: { // volume level of note (Roland GS NRPN)
+                             if (pChannel->pScript->handlerRpn) {
-                                     const uint note = NrpnCtrlLSB;
+                                 const event_id_t eventID =
-                                     const uint vol  = itControlChangeEvent->Param.CC.Value;
+                                     pEventPool->getID(itControlChangeEvent);
-                                     dmsg(4,("Note Volume NRPN received (note=%d,vol=%d).\n", note, vol));
+                                 // run the RPN script handler
-                                     if (note < 128 && vol < 128)
+                                 ProcessEventByScript(
-                                         pChannel->pMIDIKeyInfo[note].Volume = VolumeCurve[vol];
+                                     pChannel, itControlChangeEvent,
-                                     break;
+                                     pChannel->pScript->handlerRpn
-                                 }
+                                 );
-                                 case 0x1c: { // panpot of note (Roland GS NRPN)
+                                 // if RPN event was dropped by script, abort
-                                     const uint note = NrpnCtrlLSB;
+                                 // here to avoid hard coded RPN processing below
-                                     const uint pan  = itControlChangeEvent->Param.CC.Value;
+                                 if (!pEventPool->fromID(eventID)) {
-                                     dmsg(4,("Note Pan NRPN received (note=%d,pan=%d).\n", note, pan));
+                                     // to prevent other data entry messages to be misenterpreted as RPN value
-                                     if (note < 128 && pan < 128) {
+                                     pChannel->ResetMidiRpnParameter();
-                                         pChannel->pMIDIKeyInfo[note].PanLeft  = PanCurve[128 - pan];
-                                         pChannel->pMIDIKeyInfo[note].PanRight = PanCurve[pan];
-                                     }
-                                     break;
-                                 }
-                                 case 0x1d: { // reverb send of note (Roland GS NRPN)
-                                     const uint note = NrpnCtrlLSB;
-                                     const float reverb = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
-                                     dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%f).\n", note, reverb));
-                                     if (note < 128)
-                                         pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;
                                      break;
                                  }
-                                 case 0x1e: { // chorus send of note (Roland GS NRPN)
+                             }
-                                     const uint note = NrpnCtrlLSB;
-                                     const float chorus = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
+                             // do the actual (hard-coded) RPN value change processing
-                                     dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%f).\n", note, chorus));
+                             ProcessHardcodedRpn(pEngineChannel, itControlChangeEvent);
-                                     if (note < 128)
-                                         pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;
+                             // to prevent other data entry messages to be misenterpreted as RPN value
+                             pChannel->ResetMidiRpnParameter();
+                         } else if (pChannel->GetMidiNrpnParameter() >= 0) { // NRPN parameter number was sent previously ...
+                             int ch = itControlChangeEvent->Param.CC.Channel;
+                             int param = pChannel->GetMidiNrpnParameter();
+                             int value = itControlChangeEvent->Param.CC.Value << 7;
+                             // transform event type: CC event -> NRPN event
+                             itControlChangeEvent->Type = Event::type_nrpn;
+                             itControlChangeEvent->Param.RPN.Channel = ch;
+                             itControlChangeEvent->Param.RPN.Parameter = param;
+                             itControlChangeEvent->Param.RPN.Value = value;
+                             // if there's a NRPN script handler, run it ...
+                             if (pChannel->pScript->handlerNrpn) {
+                                 const event_id_t eventID =
+                                     pEventPool->getID(itControlChangeEvent);
+                                 // run the NRPN script handler
+                                 ProcessEventByScript(
+                                     pChannel, itControlChangeEvent,
+                                     pChannel->pScript->handlerNrpn
+                                 );
+                                 // if NRPN event was dropped by script, abort
+                                 // here to avoid hard coded NRPN processing below
+                                 if (!pEventPool->fromID(eventID)) {
+                                     // to prevent other data entry messages to be misenterpreted as NRPN value
+                                     pChannel->ResetMidiNrpnParameter();
                                      break;
                                  }
                              }
-                             // to prevent other MIDI CC #6 messages to be misenterpreted as NRPN controller data
-                             pChannel->ResetMidiNrpnController();
+                             // do the actual (hard-coded) NRPN value change processing
+                             ProcessHardcodedNrpn(pEngineChannel, itControlChangeEvent);
+                             // to prevent other data entry messages to be misenterpreted as NRPN value
+                             pChannel->ResetMidiNrpnParameter();
                          }
                          break;
                      }
-Line 1281 
 namespace LinuxSampler {
+Line 1575 
 namespace LinuxSampler {
                          pChannel->iLastPanRequest = itControlChangeEvent->Param.CC.Value;
                          break;
                      }
+                     case 38: { // data entry (LSB)
+                         //dmsg(1,("DATA ENTRY LSB %d\n", itControlChangeEvent->Param.CC.Value));
+                         int value = 0;
+                         // look-back: if previous MIDI event was data entry MSB,
+                         // then obtain that value for the MSB value portion
+                         if (isPrevEventCCNr(itControlChangeEvent, 6))
+                             value = prevEventOf(itControlChangeEvent)->Param.CC.Value << 7;
+                         if (pChannel->GetMidiRpnParameter() >= 0) { // RPN parameter number was sent previously ...
+                             int ch = itControlChangeEvent->Param.CC.Channel;
+                             int param = pChannel->GetMidiRpnParameter();
+                             value |= itControlChangeEvent->Param.CC.Value;
+                             // transform event type: CC event -> RPN event
+                             itControlChangeEvent->Type = Event::type_rpn;
+                             itControlChangeEvent->Param.RPN.Channel = ch;
+                             itControlChangeEvent->Param.RPN.Parameter = param;
+                             itControlChangeEvent->Param.RPN.Value = value;
+                             // if there's a RPN script handler, run it ...
+                             if (pChannel->pScript->handlerRpn) {
+                                 const event_id_t eventID =
+                                     pEventPool->getID(itControlChangeEvent);
+                                 // run the RPN script handler
+                                 ProcessEventByScript(
+                                     pChannel, itControlChangeEvent,
+                                     pChannel->pScript->handlerRpn
+                                 );
+                                 // if RPN event was dropped by script, abort
+                                 // here to avoid hard coded RPN processing below
+                                 if (!pEventPool->fromID(eventID)) {
+                                     // to prevent other data entry messages to be misenterpreted as RPN value
+                                     pChannel->ResetMidiRpnParameter();
+                                     break;
+                                 }
+                             }
+                             // do the actual (hard-coded) RPN value change processing
+                             ProcessHardcodedRpn(pEngineChannel, itControlChangeEvent);
+                             // to prevent other data entry messages to be misenterpreted as RPN value
+                             pChannel->ResetMidiRpnParameter();
+                         } else if (pChannel->GetMidiNrpnParameter() >= 0) { // NRPN parameter number was sent previously ...
+                             int ch = itControlChangeEvent->Param.CC.Channel;
+                             int param = pChannel->GetMidiNrpnParameter();
+                             value |= itControlChangeEvent->Param.CC.Value;
+                             // transform event type: CC event -> NRPN event
+                             itControlChangeEvent->Type = Event::type_nrpn;
+                             itControlChangeEvent->Param.RPN.Channel = ch;
+                             itControlChangeEvent->Param.RPN.Parameter = param;
+                             itControlChangeEvent->Param.RPN.Value = value;
+                             // if there's a NRPN script handler, run it ...
+                             if (pChannel->pScript->handlerNrpn) {
+                                 const event_id_t eventID =
+                                     pEventPool->getID(itControlChangeEvent);
+                                 // run the NRPN script handler
+                                 ProcessEventByScript(
+                                     pChannel, itControlChangeEvent,
+                                     pChannel->pScript->handlerNrpn
+                                 );
+                                 // if NRPN event was dropped by script, abort
+                                 // here to avoid hard coded NRPN processing below
+                                 if (!pEventPool->fromID(eventID)) {
+                                     // to prevent other data entry messages to be misenterpreted as NRPN value
+                                     pChannel->ResetMidiNrpnParameter();
+                                     break;
+                                 }
+                             }
+                             // do the actual (hard-coded) NRPN value change processing
+                             ProcessHardcodedNrpn(pEngineChannel, itControlChangeEvent);
+                             // to prevent other data entry messages to be misenterpreted as NRPN value
+                             pChannel->ResetMidiNrpnParameter();
+                         }
+                         break;
+                     }
                      case 64: { // sustain
                          if (itControlChangeEvent->Param.CC.Value >= 64 && !pChannel->SustainPedal) {
                              dmsg(4,("DAMPER (RIGHT) PEDAL DOWN\n"));
-Line 1354 
 namespace LinuxSampler {
+Line 1728 
 namespace LinuxSampler {
                          }
                          break;
                      }
-                     case 98: { // NRPN controller LSB
+                     case 98: { // NRPN parameter LSB
                          dmsg(4,("NRPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
-                         pEngineChannel->SetMidiNrpnControllerLsb(itControlChangeEvent->Param.CC.Value);
+                         pEngineChannel->SetMidiNrpnParameterLsb(itControlChangeEvent->Param.CC.Value);
                          break;
                      }
-                     case 99: { // NRPN controller MSB
+                     case 99: { // NRPN parameter MSB
                          dmsg(4,("NRPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
-                         pEngineChannel->SetMidiNrpnControllerMsb(itControlChangeEvent->Param.CC.Value);
+                         pEngineChannel->SetMidiNrpnParameterMsb(itControlChangeEvent->Param.CC.Value);
                          break;
                      }
-                     case 100: { // RPN controller LSB
+                     case 100: { // RPN parameter LSB
                          dmsg(4,("RPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
-                         pEngineChannel->SetMidiRpnControllerLsb(itControlChangeEvent->Param.CC.Value);
+                         pEngineChannel->SetMidiRpnParameterLsb(itControlChangeEvent->Param.CC.Value);
                          break;
                      }
-                     case 101: { // RPN controller MSB
+                     case 101: { // RPN parameter MSB
                          dmsg(4,("RPN MSB %d\n", itControlChangeEvent->Param.CC.Value));
-                         pEngineChannel->SetMidiRpnControllerMsb(itControlChangeEvent->Param.CC.Value);
+                         pEngineChannel->SetMidiRpnParameterMsb(itControlChangeEvent->Param.CC.Value);
                          break;
                      }
-Line 1407 
 namespace LinuxSampler {
+Line 1781 
 namespace LinuxSampler {
                  }
              }
+             /**
+              * Process MIDI RPN events with hard coded behavior.
+              *
+              * @param pEngineChannel - engine channel on which the MIDI RPN
+              *                         event was received
+              * @param itRpnEvent - the actual MIDI RPN event
+              */
+             void ProcessHardcodedRpn(EngineChannel* pEngineChannel,
+                                      Pool<Event>::Iterator& itRpnEvent)
+             {
+                 EngineChannelBase<V, R, I>* pChannel =
+                     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 if (itRpnEvent->Param.RPN.Parameter == 2) { // coarse tuning in half tones
+                     int transpose = (int) itRpnEvent->Param.RPN.ValueMSB() - 64;
+                     // limit to +- two octaves for now
+                     transpose = RTMath::Min(transpose,  24);
+                     transpose = RTMath::Max(transpose, -24);
+                     pChannel->GlobalTranspose = transpose;
+                     // workaround, so we won't have hanging notes
+                     pChannel->ReleaseAllVoices(itRpnEvent);
+                 }
+             }
+             /**
+              * Process MIDI NRPN events with hard coded behavior.
+              *
+              * @param pEngineChannel - engine channel on which the MIDI NRPN
+              *                         event was received
+              * @param itRpnEvent - the actual MIDI NRPN event
+              */
+             void ProcessHardcodedNrpn(EngineChannel* pEngineChannel,
+                                       Pool<Event>::Iterator& itNrpnEvent)
+             {
+                 EngineChannelBase<V, R, I>* pChannel =
+                     static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 switch (itNrpnEvent->Param.NRPN.ParameterMSB()) {
+                     case 0x1a: { // volume level of note (Roland GS NRPN)
+                         const uint note = itNrpnEvent->Param.NRPN.ParameterLSB();
+                         const uint vol  = itNrpnEvent->Param.NRPN.ValueMSB();
+                         dmsg(4,("Note Volume NRPN received (note=%d,vol=%d).\n", note, vol));
+                         if (note < 128 && vol < 128)
+                             pChannel->pMIDIKeyInfo[note].Volume = VolumeCurve[vol];
+                         break;
+                     }
+                     case 0x1c: { // panpot of note (Roland GS NRPN)
+                         const uint note = itNrpnEvent->Param.NRPN.ParameterLSB();
+                         const uint pan  = itNrpnEvent->Param.NRPN.ValueMSB();
+                         dmsg(4,("Note Pan NRPN received (note=%d,pan=%d).\n", note, pan));
+                         if (note < 128 && pan < 128) {
+                             pChannel->pMIDIKeyInfo[note].PanLeft  = PanCurve[128 - pan];
+                             pChannel->pMIDIKeyInfo[note].PanRight = PanCurve[pan];
+                         }
+                         break;
+                     }
+                     case 0x1d: { // reverb send of note (Roland GS NRPN)
+                         const uint note = itNrpnEvent->Param.NRPN.ParameterLSB();
+                         const float reverb = float(itNrpnEvent->Param.NRPN.Value) / 16383.f;
+                         dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%f).\n", note, reverb));
+                         if (note < 128)
+                             pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;
+                         break;
+                     }
+                     case 0x1e: { // chorus send of note (Roland GS NRPN)
+                         const uint note = itNrpnEvent->Param.NRPN.ParameterLSB();
+                         const float chorus = float(itNrpnEvent->Param.NRPN.Value) / 16383.f;
+                         dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%f).\n", note, chorus));
+                         if (note < 128)
+                             pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;
+                         break;
+                     }
+                 }
+             }
              virtual D* CreateDiskThread() = 0;
              /**
-Line 1415 
 namespace LinuxSampler {
+Line 1864 
 namespace LinuxSampler {
               *  @param pEngineChannel - engine channel on which this event occurred on
               *  @param itNoteOnEvent - key, velocity and time stamp of the event
               */
-             virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
+             virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) OVERRIDE {
                  EngineChannelBase<V, R, I>* pChannel =
                          static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
-                 //HACK: we should better add the transpose value only to the most mandatory places (like for retrieving the region and calculating the tuning), because otherwise voices will unintendedly survive when changing transpose while playing
-                 int k = itNoteOnEvent->Param.Note.Key + pChannel->GlobalTranspose;
-                 if (k < 0 || k > 127) return; //ignore keys outside the key range
-                 itNoteOnEvent->Param.Note.Key += pChannel->GlobalTranspose;
-                 int vel = itNoteOnEvent->Param.Note.Velocity;
                  const int key = itNoteOnEvent->Param.Note.Key;
+                 const int vel = itNoteOnEvent->Param.Note.Velocity;
+                 if (key < 0 || key > 127) return; // ignore event, key outside allowed key range
                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
-                 pChannel->listeners.PreProcessNoteOn(key, vel);
+                 // There are real MIDI note-on events (Event::type_note_on) and
+                 // programmatically spawned notes (Event::type_play_note). We have
+                 // to distinguish between them, since certain processing below
+                 // must only be done on real MIDI note-on events (i.e. for
+                 // correctly updating which MIDI keys are currently pressed down).
+                 const bool isRealMIDINoteOnEvent = itNoteOnEvent->Type == Event::type_note_on;
+                 if (isRealMIDINoteOnEvent)
+                     pChannel->listeners.PreProcessNoteOn(key, vel);
                  #if !CONFIG_PROCESS_MUTED_CHANNELS
                  if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
-                     pChannel->listeners.PostProcessNoteOn(key, vel);
+                     if (isRealMIDINoteOnEvent)
+                         pChannel->listeners.PostProcessNoteOn(key, vel);
                      return;
                  }
                  #endif
                  if (!pChannel->pInstrument) {
-                     pChannel->listeners.PostProcessNoteOn(key, vel);
+                     if (isRealMIDINoteOnEvent)
+                         pChannel->listeners.PostProcessNoteOn(key, vel);
                      return; // ignore if no instrument loaded
                  }
-Line 1446 
 namespace LinuxSampler {
+Line 1902 
 namespace LinuxSampler {
                  RTList<Event>::Iterator itNoteOnEventOnKeyList = itNoteOnEvent.moveToEndOf(pKey->pEvents);
                  // if Solo Mode then kill all already active voices
-                 if (pChannel->SoloMode) {
+                 if (pChannel->SoloMode && isRealMIDINoteOnEvent) {
                      Pool<uint>::Iterator itYoungestKey = pChannel->pActiveKeys->last();
                      if (itYoungestKey) {
                          const int iYoungestKey = *itYoungestKey;
-Line 1454 
 namespace LinuxSampler {
+Line 1910 
 namespace LinuxSampler {
                          if (pOtherKey->Active) {
                              // get final portamento position of currently active voice
                              if (pChannel->PortamentoMode) {
-                                 VoiceIterator itVoice = pOtherKey->pActiveVoices->last();
+                                 NoteIterator itNote = pOtherKey->pActiveNotes->last();
-                                 if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
+                                 if (itNote) {
+                                     VoiceIterator itVoice = itNote->pActiveVoices->last();
+                                     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
+                                 }
                              }
                              // kill all voices on the (other) key
-                             VoiceIterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();
+                             for (NoteIterator itNote = pOtherKey->pActiveNotes->first(); itNote; ++itNote) {
-                             VoiceIterator end               = pOtherKey->pActiveVoices->end();
+                                 VoiceIterator itVoiceToBeKilled = itNote->pActiveVoices->first();
-                             for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
+                                 VoiceIterator end               = itNote->pActiveVoices->end();
-                                 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
+                                 for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
-                                     itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
+                                     if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
+                                         itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
+                                 }
                              }
                          }
                      }
-Line 1470 
 namespace LinuxSampler {
+Line 1931 
 namespace LinuxSampler {
                      pChannel->SoloKey = key;
                  }
-                 pChannel->ProcessKeySwitchChange(key);
+                 if (isRealMIDINoteOnEvent) {
+                     pChannel->ProcessKeySwitchChange(key);
-                 pKey->KeyPressed = true; // the MIDI key was now pressed down
+                     pKey->KeyPressed = true; // the MIDI key was now pressed down
-                 pChannel->KeyDown[key] = true; // just used as built-in %KEY_DOWN script variable
+                     pChannel->KeyDown[key] = true; // just used as built-in %KEY_DOWN script variable
-                 pKey->Velocity   = itNoteOnEventOnKeyList->Param.Note.Velocity;
+                     pKey->Velocity   = itNoteOnEventOnKeyList->Param.Note.Velocity;
-                 pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
+                     pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
+                 }
                  // cancel release process of voices on this key if needed
-                 if (pKey->Active && !pChannel->SustainPedal) {
+                 if (pKey->Active && !pChannel->SustainPedal && isRealMIDINoteOnEvent) {
                      RTList<Event>::Iterator itCancelReleaseEvent = pKey->pEvents->allocAppend();
                      if (itCancelReleaseEvent) {
                          *itCancelReleaseEvent = *itNoteOnEventOnKeyList;         // copy event
-                         itCancelReleaseEvent->Type = Event::type_cancel_release; // transform event type
+                         itCancelReleaseEvent->Type = Event::type_cancel_release_key; // transform event type
                      }
                      else dmsg(1,("Event pool emtpy!\n"));
                  }
-Line 1493 
 namespace LinuxSampler {
+Line 1956 
 namespace LinuxSampler {
                  if (!pKey->Active && !pKey->VoiceTheftsQueued)
                      pKey->pEvents->free(itNoteOnEventOnKeyList);
-                 if (!pChannel->SoloMode || pChannel->PortamentoPos < 0.0f) pChannel->PortamentoPos = (float) key;
+                 if (isRealMIDINoteOnEvent && (!pChannel->SoloMode || pChannel->PortamentoPos < 0.0f))
+                     pChannel->PortamentoPos = (float) key;
+                 //NOTE: Hmm, I guess its a matter of taste whether round robin should be advanced only on real MIDI note-on events, isn't it?
                  if (pKey->pRoundRobinIndex) {
                      (*pKey->pRoundRobinIndex)++; // counter specific for the key or region
                      pChannel->RoundRobinIndex++; // common counter for the channel
                  }
-                 pChannel->listeners.PostProcessNoteOn(key, vel);
+                 if (isRealMIDINoteOnEvent)
+                     pChannel->listeners.PostProcessNoteOn(key, vel);
              }
              /**
-Line 1527 
 namespace LinuxSampler {
+Line 1995 
 namespace LinuxSampler {
               *  @param pEngineChannel - engine channel on which this event occurred on
               *  @param itNoteOffEvent - key, velocity and time stamp of the event
               */
-             virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {
+             virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) OVERRIDE {
                  EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
-                 int k = itNoteOffEvent->Param.Note.Key + pChannel->GlobalTranspose;
-                 if (k < 0 || k > 127) return; //ignore keys outside the key range
-                 //HACK: we should better add the transpose value only to the most mandatory places (like for retrieving the region and calculating the tuning), because otherwise voices will unintendedly survive when changing transpose while playing
-                 itNoteOffEvent->Param.Note.Key += pChannel->GlobalTranspose;
-                 int vel = itNoteOffEvent->Param.Note.Velocity;
                  const int iKey = itNoteOffEvent->Param.Note.Key;
+                 const int vel  = itNoteOffEvent->Param.Note.Velocity;
+                 if (iKey < 0 || iKey > 127) return; // ignore event, key outside allowed key range
                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];
-                 pChannel->listeners.PreProcessNoteOff(iKey, vel);
+                 // There are real MIDI note-off events (Event::type_note_off) and
+                 // programmatically spawned notes (Event::type_stop_note). We have
+                 // to distinguish between them, since certain processing below
+                 // must only be done on real MIDI note-off events (i.e. for
+                 // correctly updating which MIDI keys are currently pressed down),
+                 // plus a stop-note event just releases voices of one particular
+                 // note, whereas a note-off event releases all voices on a
+                 // particular MIDI key instead.
+                 const bool isRealMIDINoteOffEvent = itNoteOffEvent->Type == Event::type_note_off;
+                 if (isRealMIDINoteOffEvent)
+                     pChannel->listeners.PreProcessNoteOff(iKey, vel);
                  #if !CONFIG_PROCESS_MUTED_CHANNELS
                  if (pEngineChannel->GetMute()) { // skip if sampler channel is muted
-                     pChannel->listeners.PostProcessNoteOff(iKey, vel);
+                     if (isRealMIDINoteOffEvent)
+                         pChannel->listeners.PostProcessNoteOff(iKey, vel);
                      return;
                  }
                  #endif
-                 pKey->KeyPressed = false; // the MIDI key was now released
+                 if (isRealMIDINoteOffEvent) {
-                 pChannel->KeyDown[iKey] = false; // just used as built-in %KEY_DOWN script variable
+                     pKey->KeyPressed = false; // the MIDI key was now released
+                     pChannel->KeyDown[iKey] = false; // just used as built-in %KEY_DOWN script variable
+                 }
                  // move event to the key's own event list
                  RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
-                 bool bShouldRelease = pKey->Active && pChannel->ShouldReleaseVoice(itNoteOffEventOnKeyList->Param.Note.Key);
+                 if (isRealMIDINoteOffEvent) {
+                     bool bShouldRelease = pKey->Active && pChannel->ShouldReleaseVoice(itNoteOffEventOnKeyList->Param.Note.Key);
-                 // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
+                     // in case Solo Mode is enabled, kill all voices on this key and respawn a voice on the highest pressed key (if any)
-                 if (pChannel->SoloMode && pChannel->pInstrument) { //TODO: this feels like too much code just for handling solo mode :P
+                     if (pChannel->SoloMode && pChannel->pInstrument) { //TODO: this feels like too much code just for handling solo mode :P
-                     bool bOtherKeysPressed = false;
+                         bool bOtherKeysPressed = false;
-                     if (iKey == pChannel->SoloKey) {
+                         if (iKey == pChannel->SoloKey) {
-                         pChannel->SoloKey = -1;
+                             pChannel->SoloKey = -1;
-                         // if there's still a key pressed down, respawn a voice (group) on the highest key
+                             // if there's still a key pressed down, respawn a voice (group) on the highest key
-                         for (int i = 127; i > 0; i--) {
+                             for (int i = 127; i > 0; i--) {
-                             MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[i];
+                                 MidiKey* pOtherKey = &pChannel->pMIDIKeyInfo[i];
-                             if (pOtherKey->KeyPressed) {
+                                 if (pOtherKey->KeyPressed) {
-                                 bOtherKeysPressed = true;
+                                     bOtherKeysPressed = true;
-                                 // make the other key the new 'currently active solo key'
+                                     // make the other key the new 'currently active solo key'
-                                 pChannel->SoloKey = i;
+                                     pChannel->SoloKey = i;
-                                 // get final portamento position of currently active voice
+                                     // get final portamento position of currently active voice
-                                 if (pChannel->PortamentoMode) {
+                                     if (pChannel->PortamentoMode) {
-                                     VoiceIterator itVoice = pKey->pActiveVoices->first();
+                                         NoteIterator itNote = pKey->pActiveNotes->first();
-                                     if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
+                                         VoiceIterator itVoice = itNote->pActiveVoices->first();
-                                 }
+                                         if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
-                                 // create a pseudo note on event
+                                     }
-                                 RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
+                                     // create a pseudo note on event
-                                 if (itPseudoNoteOnEvent) {
+                                     RTList<Event>::Iterator itPseudoNoteOnEvent = pOtherKey->pEvents->allocAppend();
-                                     // copy event
+                                     if (itPseudoNoteOnEvent) {
-                                     *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
+                                         // copy event
-                                     // transform event to a note on event
+                                         *itPseudoNoteOnEvent = *itNoteOffEventOnKeyList;
-                                     itPseudoNoteOnEvent->Type                = Event::type_note_on;
+                                         // transform event to a note on event
-                                     itPseudoNoteOnEvent->Param.Note.Key      = i;
+                                         itPseudoNoteOnEvent->Type                = Event::type_note_on; //FIXME: should probably use Event::type_play_note instead (to avoid i.e. hanging notes)
-                                     itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
+                                         itPseudoNoteOnEvent->Param.Note.Key      = i;
-                                     // allocate and trigger new voice(s) for the other key
+                                         itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
-                                     TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);
+                                         // assign a new note to this note-on event
-                                     // if neither a voice was spawned or postponed then remove note on event from key again
+                                         if (LaunchNewNote(pChannel, itPseudoNoteOnEvent)) {
-                                     if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
+                                             // allocate and trigger new voice(s) for the other key
-                                         pOtherKey->pEvents->free(itPseudoNoteOnEvent);
+                                             TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);
+                                         }
+                                         // if neither a voice was spawned or postponed then remove note on event from key again
+                                         if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
+                                             pOtherKey->pEvents->free(itPseudoNoteOnEvent);
-                                 } else dmsg(1,("Could not respawn voice, no free event left\n"));
+                                     } else dmsg(1,("Could not respawn voice, no free event left\n"));
-                                 break; // done
+                                     break; // done
+                                 }
                              }
                          }
-                     }
+                         if (bOtherKeysPressed) {
-                     if (bOtherKeysPressed) {
+                             if (pKey->Active) { // kill all voices on this key
-                         if (pKey->Active) { // kill all voices on this key
+                                 bShouldRelease = false; // no need to release, as we kill it here
-                             bShouldRelease = false; // no need to release, as we kill it here
+                                 for (NoteIterator itNote = pKey->pActiveNotes->first(); itNote; ++itNote) {
-                             VoiceIterator itVoiceToBeKilled = pKey->pActiveVoices->first();
+                                     VoiceIterator itVoiceToBeKilled = itNote->pActiveVoices->first();
-                             VoiceIterator end               = pKey->pActiveVoices->end();
+                                     VoiceIterator end               = itNote->pActiveVoices->end();
-                             for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
+                                     for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
-                                 if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
+                                         if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
-                                     itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
+                                             itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
+                                     }
+                                 }
                              }
-                         }
+                         } else pChannel->PortamentoPos = -1.0f;
-                     } else pChannel->PortamentoPos = -1.0f;
+                     }
-                 }
-                 // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
-                 if (bShouldRelease) {
-                     itNoteOffEventOnKeyList->Type = Event::type_release; // transform event type
-                     // spawn release triggered voice(s) if needed
+                     // if no solo mode (the usual case) or if solo mode and no other key pressed, then release voices on this key if needed
-                     if (pKey->ReleaseTrigger && pChannel->pInstrument) {
+                     if (bShouldRelease) {
-                         TriggerReleaseVoices(pChannel, itNoteOffEventOnKeyList);
+                         itNoteOffEventOnKeyList->Type = Event::type_release_key; // transform event type
-                         pKey->ReleaseTrigger = false;
+                         // spawn release triggered voice(s) if needed
+                         if (pKey->ReleaseTrigger & release_trigger_noteoff)
+                             ProcessReleaseTrigger(pChannel, itNoteOffEventOnKeyList, pKey);
+                     }
+                 } else if (itNoteOffEventOnKeyList->Type == Event::type_stop_note) {
+                     // This programmatically caused event is caused by a call to
+                     // the built-in instrument script function note_off(). In
+                     // contrast to a real MIDI note-off event the stop-note
+                     // event just intends to release voices of one particular note.
+                     NoteBase* pNote = pChannel->pEngine->NoteByID( itNoteOffEventOnKeyList->Param.Note.ID );
+                     if (pNote) { // the requested note is still alive ...
+                         itNoteOffEventOnKeyList->Type = Event::type_release_note; // transform event type
+                     } else { // note is dead and gone ..
+                         pKey->pEvents->free(itNoteOffEventOnKeyList); // remove stop-note event from key again
+                         return; // prevent event to be removed a 2nd time below
                      }
                  }
-Line 1622 
 namespace LinuxSampler {
+Line 2117 
 namespace LinuxSampler {
                  if (!pKey->Active && !pKey->VoiceTheftsQueued)
                      pKey->pEvents->free(itNoteOffEventOnKeyList);
-                 pChannel->listeners.PostProcessNoteOff(iKey, vel);
+                 if (isRealMIDINoteOffEvent)
+                     pChannel->listeners.PostProcessNoteOff(iKey, vel);
+             }
+             /**
+              * Called on sustain pedal up events to check and if required,
+              * launch release trigger voices on the respective active key.
+              *
+              * @param pEngineChannel - engine channel on which this event occurred on
+              * @param itEvent - release trigger event (contains note number)
+              */
+             virtual void ProcessReleaseTriggerBySustain(EngineChannel* pEngineChannel, RTList<Event>::Iterator& itEvent) OVERRIDE {
+                 EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 const int iKey = itEvent->Param.Note.Key;
+                 if (iKey < 0 || iKey > 127) return; // ignore event, key outside allowed key range
+                 MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];
+                 ProcessReleaseTrigger(pChannel, itEvent, pKey);
+             }
+             /**
+              * Called on note-off and sustain pedal up events to check and if
+              * required, launch release trigger voices on the respective active
+              * key.
+              *
+              * @param pEngineChannel - engine channel on which this event occurred on
+              * @param itEvent - note off event / release trigger event
+              * @param pKey - key on which the release trigger voices shall be spawned
+              */
+             inline void ProcessReleaseTrigger(EngineChannelBase<V, R, I>* pChannel, RTList<Event>::Iterator& itEvent, MidiKey* pKey) {
+                 // spawn release triggered voice(s) if needed
+                 if (pKey->ReleaseTrigger && pChannel->pInstrument) {
+                     // assign a new note to this release event
+                     if (LaunchNewNote(pChannel, itEvent)) {
+                         // allocate and trigger new release voice(s)
+                         TriggerReleaseVoices(pChannel, itEvent);
+                     }
+                     pKey->ReleaseTrigger = release_trigger_none;
+                 }
+             }
+             /**
+              * Called on "kill note" events, which currently only happens on
+              * built-in real-time instrument script function fade_out(). This
+              * method only fulfills one task: moving the even to the Note's own
+              * event list so that its voices can process the kill event sample
+              * accurately.
+              */
+             void ProcessKillNote(EngineChannel* pEngineChannel, RTList<Event>::Iterator& itEvent) {
+                 EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 NoteBase* pNote = pChannel->pEngine->NoteByID( itEvent->Param.Note.ID );
+                 if (!pNote || pNote->hostKey < 0 || pNote->hostKey >= 128) return;
+                 // move note kill event to its MIDI key
+                 MidiKey* pKey = &pChannel->pMIDIKeyInfo[pNote->hostKey];
+                 itEvent.moveToEndOf(pKey->pEvents);
+             }
+             /**
+              * Called on note synthesis parameter change events. These are
+              * internal events caused by calling built-in real-time instrument
+              * script functions like change_vol(), change_tune(), etc.
+              *
+              * This method performs two tasks:
+              *
+              * - It converts the event's relative values changes (Deltas) to
+              *   the respective final new synthesis parameter value (AbsValue),
+              *   for that particular moment of the event that is.
+              *
+              * - It moves the individual events to the Note's own event list
+              *   (or actually to the event list of the MIDI key), so that
+              *   voices can process those events sample accurately.
+              *
+              * @param pEngineChannel - engine channel on which this event occurred on
+              * @param itEvent - note synthesis parameter change event
+              */
+             virtual void ProcessNoteSynthParam(EngineChannel* pEngineChannel, RTList<Event>::Iterator& itEvent) {
+                 EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
+                 NoteBase* pNote = pChannel->pEngine->NoteByID( itEvent->Param.NoteSynthParam.NoteID );
+                 if (!pNote || pNote->hostKey < 0 || pNote->hostKey >= 128) return;
+                 switch (itEvent->Param.NoteSynthParam.Type) {
+                     case Event::synth_param_volume:
+                         pNote->apply(itEvent, &NoteBase::_Override::Volume);
+                         break;
+                     case Event::synth_param_volume_time:
+                         pNote->Override.VolumeTime = itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         break;
+                     case Event::synth_param_volume_curve:
+                         itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         pNote->Override.VolumeCurve = (fade_curve_t) itEvent->Param.NoteSynthParam.AbsValue;
+                         break;
+                     case Event::synth_param_pitch:
+                         pNote->apply(itEvent, &NoteBase::_Override::Pitch);
+                         break;
+                     case Event::synth_param_pitch_time:
+                         pNote->Override.PitchTime = itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         break;
+                     case Event::synth_param_pitch_curve:
+                         itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         pNote->Override.PitchCurve = (fade_curve_t) itEvent->Param.NoteSynthParam.AbsValue;
+                         break;
+                     case Event::synth_param_pan:
+                         pNote->apply(itEvent, &NoteBase::_Override::Pan);
+                         break;
+                     case Event::synth_param_pan_time:
+                         pNote->Override.PanTime = itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         break;
+                     case Event::synth_param_pan_curve:
+                         itEvent->Param.NoteSynthParam.AbsValue = itEvent->Param.NoteSynthParam.Delta;
+                         pNote->Override.PanCurve = (fade_curve_t) itEvent->Param.NoteSynthParam.AbsValue;
+                         break;
+                     case Event::synth_param_cutoff:
+                         pNote->apply(itEvent, &NoteBase::_Override::Cutoff);
+                         break;
+                     case Event::synth_param_resonance:
+                         pNote->apply(itEvent, &NoteBase::_Override::Resonance);
+                         break;
+                     case Event::synth_param_attack:
+                         pNote->apply(itEvent, &NoteBase::_Override::Attack);
+                         break;
+                     case Event::synth_param_decay:
+                         pNote->apply(itEvent, &NoteBase::_Override::Decay);
+                         break;
+                     case Event::synth_param_sustain:
+                         pNote->apply(itEvent, &NoteBase::_Override::Sustain);
+                         break;
+                     case Event::synth_param_release:
+                         pNote->apply(itEvent, &NoteBase::_Override::Release);
+                         break;
+                     case Event::synth_param_cutoff_attack:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffAttack);
+                         break;
+                     case Event::synth_param_cutoff_decay:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffDecay);
+                         break;
+                     case Event::synth_param_cutoff_sustain:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffSustain);
+                         break;
+                     case Event::synth_param_cutoff_release:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffRelease);
+                         break;
+                     case Event::synth_param_amp_lfo_depth:
+                         pNote->apply(itEvent, &NoteBase::_Override::AmpLFODepth);
+                         break;
+                     case Event::synth_param_amp_lfo_freq:
+                         pNote->apply(itEvent, &NoteBase::_Override::AmpLFOFreq);
+                         break;
+                     case Event::synth_param_cutoff_lfo_depth:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffLFODepth);
+                         break;
+                     case Event::synth_param_cutoff_lfo_freq:
+                         pNote->apply(itEvent, &NoteBase::_Override::CutoffLFOFreq);
+                         break;
+                     case Event::synth_param_pitch_lfo_depth:
+                         pNote->apply(itEvent, &NoteBase::_Override::PitchLFODepth);
+                         break;
+                     case Event::synth_param_pitch_lfo_freq:
+                         pNote->apply(itEvent, &NoteBase::_Override::PitchLFOFreq);
+                         break;
+                 }
+                 // move note parameter event to its MIDI key
+                 MidiKey* pKey = &pChannel->pMIDIKeyInfo[pNote->hostKey];
+                 itEvent.moveToEndOf(pKey->pEvents);
              }
              /**
               *  Reset all voices and disk thread and clear input event queue and all
               *  control and status variables. This method is protected by a mutex.
               */
-             virtual void ResetInternal() {
+             virtual void ResetInternal() OVERRIDE {
                  LockGuard lock(ResetInternalMutex);
                  // make sure that the engine does not get any sysex messages
-Line 1642 
 namespace LinuxSampler {
+Line 2307 
 namespace LinuxSampler {
                  pVoiceStealingQueue->clear();
                  itLastStolenVoice          = VoiceIterator();
                  itLastStolenVoiceGlobally  = VoiceIterator();
+                 itLastStolenNote           = NoteIterator();
+                 itLastStolenNoteGlobally   = NoteIterator();
                  iuiLastStolenKey           = RTList<uint>::Iterator();
                  iuiLastStolenKeyGlobally   = RTList<uint>::Iterator();
                  pLastStolenChannel         = NULL;
+                 // reset all notes
+                 pNotePool->clear();
+                 for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
+                      itNote = pNotePool->allocAppend())
+                 {
+                     itNote->reset();
+                 }
+                 pNotePool->clear();
                  // reset all voices
+                 pVoicePool->clear();
                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
                      iterVoice->Reset();
                  }
-Line 1676 
 namespace LinuxSampler {
+Line 2353 
 namespace LinuxSampler {
               * @param pEngineChannel - engine channel on which all voices should be killed
               * @param itKillEvent    - event which caused this killing of all voices
               */
-             virtual void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) {
+             virtual void KillAllVoices(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itKillEvent) OVERRIDE {
                  EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
                  int count = pChannel->KillAllVoices(itKillEvent);
                  VoiceSpawnsLeft -= count; //FIXME: just a temporary workaround, we should check the cause in StealVoice() instead
-Line 1711 
 namespace LinuxSampler {
+Line 2388 
 namespace LinuxSampler {
                  bool                    HandleKeyGroupConflicts
              ) = 0;
-             virtual int GetMinFadeOutSamples() { return MinFadeOutSamples; }
+             virtual int GetMinFadeOutSamples() OVERRIDE { return MinFadeOutSamples; }
              int InitNewVoice (
                  EngineChannelBase<V, R, I>*  pChannel,
-Line 1730 
 namespace LinuxSampler {
+Line 2407 
 namespace LinuxSampler {
                      // launch the new voice
                      if (itNewVoice->Trigger(pChannel, itNoteOnEvent, pChannel->Pitch, pRegion, VoiceType, iKeyGroup) < 0) {
                          dmsg(4,("Voice not triggered\n"));
-                         pKey->pActiveVoices->free(itNewVoice);
+                         GetVoicePool()->free(itNewVoice);
                      }
                      else { // on success
                          --VoiceSpawnsLeft;
-                         if (!pKey->Active) { // mark as active key
-                             pKey->Active = true;
+                         // should actually be superfluous now, since this is
-                             pKey->itSelf = pChannel->pActiveKeys->allocAppend();
+                         // already done in LaunchNewNote()
-                             *pKey->itSelf = itNoteOnEvent->Param.Note.Key;
+                         pChannel->markKeyAsActive(pKey);
-                         }
-                         if (itNewVoice->Type & Voice::type_release_trigger_required) pKey->ReleaseTrigger = true; // mark key for the need of release triggered voice(s)
+                         if (itNewVoice->Type & Voice::type_release_trigger_required)
+                             pKey->ReleaseTrigger |= itNewVoice->GetReleaseTriggerFlags(); // mark key for the need of release triggered voice(s)
                          return 0; // success
                      }
                  }
-Line 1779 
 namespace LinuxSampler {
+Line 2457 
 namespace LinuxSampler {
              }
          private:
+             Pool< Note<V> >* pNotePool;
+             Pool<note_id_t> noteIDPool;
              Pool<V>*    pVoicePool;            ///< Contains all voices that can be activated.
              Pool<RR*>   SuspendedRegions;
              Mutex       SuspendedRegionsMutex;

 Legend:



Removed from v.2871
 


changed lines


 
Added in v.3690
 Legend:



Removed from v.2871
 


changed lines


 
Added in v.3690
-Removed from v.2871
+Added in v.3690

	ViewVC Help
Powered by ViewVC