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

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

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

revision 2596 by schoenebeck, Thu Jun 5 19:39:12 2014 UTC revision 2884 by schoenebeck, Wed Apr 20 15:22:58 2016 UTC
# Line 4  Line 4 
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *   *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
6   *   Copyright (C) 2005-2008 Christian Schoenebeck                         *   *   Copyright (C) 2005-2008 Christian Schoenebeck                         *
7   *   Copyright (C) 2009-2013 Christian Schoenebeck and Grigor Iliev        *   *   Copyright (C) 2009-2012 Christian Schoenebeck and Grigor Iliev        *
8     *   Copyright (C) 2012-2016 Christian Schoenebeck and Andreas Persson     *
9   *                                                                         *   *                                                                         *
10   *   This program is free software; you can redistribute it and/or modify  *   *   This program is free software; you can redistribute it and/or modify  *
11   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 32  Line 33 
33  #include "InstrumentManager.h"  #include "InstrumentManager.h"
34  #include "../common/global_private.h"  #include "../common/global_private.h"
35    
36    // a bit headroom over CONFIG_MAX_VOICES to avoid minor complications i.e. under voice stealing conditions
37    #define MAX_NOTES_HEADROOM  3
38    #define GLOBAL_MAX_NOTES    (GLOBAL_MAX_VOICES * MAX_NOTES_HEADROOM)
39    
40  namespace LinuxSampler {  namespace LinuxSampler {
41    
# Line 45  namespace LinuxSampler { Line 49  namespace LinuxSampler {
49          class IM  /* Instrument Manager */,          class IM  /* Instrument Manager */,
50          class I   /* Instrument */          class I   /* Instrument */
51      >      >
52      class EngineBase: public AbstractEngine, public RegionPools<R>, public VoicePool<V> {      class EngineBase: public AbstractEngine, public RegionPools<R>, public NotePool<V> {
53    
54          public:          public:
55                typedef typename RTList< Note<V> >::Iterator NoteIterator;
56              typedef typename RTList<V>::Iterator VoiceIterator;              typedef typename RTList<V>::Iterator VoiceIterator;
57              typedef typename Pool<V>::Iterator PoolVoiceIterator;              typedef typename Pool<V>::Iterator PoolVoiceIterator;
58              typedef typename RTList<RR*>::Iterator RootRegionIterator;              typedef typename RTList<RR*>::Iterator RootRegionIterator;
59              typedef typename MidiKeyboardManager<V>::MidiKey MidiKey;              typedef typename MidiKeyboardManager<V>::MidiKey MidiKey;
60                            
61              EngineBase() : SuspendedRegions(128) {              EngineBase() : SuspendedRegions(128), noteIDPool(GLOBAL_MAX_NOTES) {
62                  pDiskThread          = NULL;                  pDiskThread          = NULL;
63                    pNotePool            = new Pool< Note<V> >(GLOBAL_MAX_NOTES);
64                    pNotePool->setPoolElementIDsReservedBits(INSTR_SCRIPT_EVENT_ID_RESERVED_BITS);
65                  pVoicePool           = new Pool<V>(GLOBAL_MAX_VOICES);                  pVoicePool           = new Pool<V>(GLOBAL_MAX_VOICES);
66                  pRegionPool[0]       = new Pool<R*>(GLOBAL_MAX_VOICES);                  pRegionPool[0]       = new Pool<R*>(GLOBAL_MAX_VOICES);
67                  pRegionPool[1]       = new Pool<R*>(GLOBAL_MAX_VOICES);                  pRegionPool[1]       = new Pool<R*>(GLOBAL_MAX_VOICES);
68                  pVoiceStealingQueue  = new RTList<Event>(pEventPool);                  pVoiceStealingQueue  = new RTList<Event>(pEventPool);
69                  iMaxDiskStreams      = GLOBAL_MAX_STREAMS;                  iMaxDiskStreams      = GLOBAL_MAX_STREAMS;
70    
71                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {                  // init all Voice objects in voice pool
72                    for (VoiceIterator iterVoice = pVoicePool->allocAppend();
73                         iterVoice; iterVoice = pVoicePool->allocAppend())
74                    {
75                      iterVoice->SetEngine(this);                      iterVoice->SetEngine(this);
76                  }                  }
77                  pVoicePool->clear();                  pVoicePool->clear();
78    
79                    // init all Note objects in note pool
80                    for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
81                         itNote = pNotePool->allocAppend())
82                    {
83                        itNote->init(pVoicePool, &noteIDPool);
84                    }
85                    pNotePool->clear();
86    
87                  ResetInternal();                  ResetInternal();
88                  ResetScaleTuning();                  ResetScaleTuning();
89                  ResetSuspendedRegions();                  ResetSuspendedRegions();
# Line 79  namespace LinuxSampler { Line 97  namespace LinuxSampler {
97                      dmsg(1,("OK\n"));                      dmsg(1,("OK\n"));
98                  }                  }
99    
100                    if (pNotePool) {
101                        pNotePool->clear();
102                        delete pNotePool;
103                    }
104    
105                  if (pVoicePool) {                  if (pVoicePool) {
106                      pVoicePool->clear();                      pVoicePool->clear();
107                      delete pVoicePool;                      delete pVoicePool;
# Line 235  namespace LinuxSampler { Line 258  namespace LinuxSampler {
258                      pChannel->ResetRegionsInUse(pRegionPool);                      pChannel->ResetRegionsInUse(pRegionPool);
259                  }                  }
260    
261                    // FIXME: Shouldn't all those pool elements be freed before resizing the pools?
262                  try {                  try {
263                      pVoicePool->resizePool(iVoices);                      pVoicePool->resizePool(iVoices);
264                        pNotePool->resizePool(iVoices * MAX_NOTES_HEADROOM);
265                        noteIDPool.resizePool(iVoices * MAX_NOTES_HEADROOM);
266                  } catch (...) {                  } catch (...) {
267                      throw Exception("FATAL: Could not resize voice pool!");                      throw Exception("FATAL: Could not resize voice pool!");
268                  }                  }
269    
270                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {                  for (VoiceIterator iterVoice = pVoicePool->allocAppend();
271                         iterVoice; iterVoice = pVoicePool->allocAppend())
272                    {
273                      iterVoice->SetEngine(this);                      iterVoice->SetEngine(this);
274                      iterVoice->pDiskThread = this->pDiskThread;                      iterVoice->pDiskThread = this->pDiskThread;
275                  }                  }
276                  pVoicePool->clear();                  pVoicePool->clear();
277    
278                    for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
279                         itNote = pNotePool->allocAppend())
280                    {
281                        itNote->init(pVoicePool, &noteIDPool);
282                    }
283                    pNotePool->clear();
284    
285                  PostSetMaxVoices(iVoices);                  PostSetMaxVoices(iVoices);
286                  ResumeAll();                  ResumeAll();
287              }              }
# Line 315  namespace LinuxSampler { Line 350  namespace LinuxSampler {
350                      MinFadeOutSamples = MaxSamplesPerCycle;                      MinFadeOutSamples = MaxSamplesPerCycle;
351                      // lower minimum release time                      // lower minimum release time
352                      const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;                      const float minReleaseTime = (float) MaxSamplesPerCycle / (float) SampleRate;
353                        pVoicePool->clear();
354                      for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {                      for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
355                          iterVoice->CalculateFadeOutCoeff(minReleaseTime, SampleRate);                          iterVoice->CalculateFadeOutCoeff(minReleaseTime, SampleRate);
356                      }                      }
# Line 335  namespace LinuxSampler { Line 371  namespace LinuxSampler {
371                      exit(EXIT_FAILURE);                      exit(EXIT_FAILURE);
372                  }                  }
373    
374                    pVoicePool->clear();
375                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
376                      iterVoice->pDiskThread = this->pDiskThread;                      iterVoice->pDiskThread = this->pDiskThread;
377                      dmsg(3,("d"));                      dmsg(3,("d"));
# Line 432  namespace LinuxSampler { Line 469  namespace LinuxSampler {
469               * @param pRegion - region the engine shall stop using               * @param pRegion - region the engine shall stop using
470               */               */
471              virtual void Suspend(RR* pRegion) {              virtual void Suspend(RR* pRegion) {
472                  dmsg(2,("EngineBase: Suspending Region %x ...\n",pRegion));                  dmsg(2,("EngineBase: Suspending Region %p ...\n",(void*)pRegion));
473                  {                  {
474                      LockGuard lock(SuspendedRegionsMutex);                      LockGuard lock(SuspendedRegionsMutex);
475                      SuspensionChangeOngoing.Set(true);                      SuspensionChangeOngoing.Set(true);
476                      pPendingRegionSuspension = pRegion;                      pPendingRegionSuspension = pRegion;
477                      SuspensionChangeOngoing.WaitAndUnlockIf(true);                      SuspensionChangeOngoing.WaitAndUnlockIf(true);
478                  }                  }
479                  dmsg(2,("EngineBase: Region %x suspended.",pRegion));                  dmsg(2,("EngineBase: Region %p suspended.",(void*)pRegion));
480              }              }
481    
482              /**              /**
# Line 449  namespace LinuxSampler { Line 486  namespace LinuxSampler {
486               * @param pRegion - region the engine shall be allowed to use again               * @param pRegion - region the engine shall be allowed to use again
487               */               */
488              virtual void Resume(RR* pRegion) {              virtual void Resume(RR* pRegion) {
489                  dmsg(2,("EngineBase: Resuming Region %x ...\n",pRegion));                  dmsg(2,("EngineBase: Resuming Region %p ...\n",(void*)pRegion));
490                  {                  {
491                      LockGuard lock(SuspendedRegionsMutex);                      LockGuard lock(SuspendedRegionsMutex);
492                      SuspensionChangeOngoing.Set(true);                      SuspensionChangeOngoing.Set(true);
493                      pPendingRegionResumption = pRegion;                      pPendingRegionResumption = pRegion;
494                      SuspensionChangeOngoing.WaitAndUnlockIf(true);                      SuspensionChangeOngoing.WaitAndUnlockIf(true);
495                  }                  }
496                  dmsg(2,("EngineBase: Region %x resumed.\n",pRegion));                  dmsg(2,("EngineBase: Region %p resumed.\n",(void*)pRegion));
497              }              }
498    
499              virtual void ResetSuspendedRegions() {              virtual void ResetSuspendedRegions() {
# Line 564  namespace LinuxSampler { Line 601  namespace LinuxSampler {
601                  return pRegionPool[index];                  return pRegionPool[index];
602              }              }
603    
604              // implementation of abstract method derived from class 'LinuxSampler::VoicePool'              // implementation of abstract methods derived from class 'LinuxSampler::NotePool'
605              virtual Pool<V>* GetVoicePool() { return pVoicePool; }              virtual Pool<V>* GetVoicePool() OVERRIDE { return pVoicePool; }
606                virtual Pool< Note<V> >* GetNotePool() OVERRIDE { return pNotePool; }
607                virtual Pool<note_id_t>* GetNodeIDPool() OVERRIDE { return &noteIDPool; }
608    
609              D* GetDiskThread() { return pDiskThread; }              D* GetDiskThread() { return pDiskThread; }
610    
# Line 585  namespace LinuxSampler { Line 624  namespace LinuxSampler {
624                  }                  }
625    
626                  virtual bool Process(MidiKey* pMidiKey) OVERRIDE {                  virtual bool Process(MidiKey* pMidiKey) OVERRIDE {
627                      VoiceIterator itVoice = pMidiKey->pActiveVoices->first();                      NoteIterator  itNote  = pMidiKey->pActiveNotes->first();
628                        VoiceIterator itVoice = itNote->pActiveVoices->first();
629                      // if current key is not associated with this region, skip this key                      // if current key is not associated with this region, skip this key
630                      if (itVoice->GetRegion()->GetParent() != pPendingRegionSuspension) return false;                      if (itVoice->GetRegion()->GetParent() != pPendingRegionSuspension) return false;
631    
# Line 608  namespace LinuxSampler { Line 648  namespace LinuxSampler {
648    
649              int                          ActiveVoiceCountTemp;  ///< number of currently active voices (for internal usage, will be used for incrementation)              int                          ActiveVoiceCountTemp;  ///< number of currently active voices (for internal usage, will be used for incrementation)
650              VoiceIterator                itLastStolenVoice;     ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.              VoiceIterator                itLastStolenVoice;     ///< Only for voice stealing: points to the last voice which was theft in current audio fragment, NULL otherwise.
651                NoteIterator                 itLastStolenNote;      ///< Only for voice stealing: points to the last note from which was theft in current audio fragment, NULL otherwise.
652              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.              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.
653              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.              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.
654              VoiceIterator                itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally              VoiceIterator                itLastStolenVoiceGlobally; ///< Same as itLastStolenVoice, but engine globally
655                NoteIterator                 itLastStolenNoteGlobally; ///< Same as itLastStolenNote, but engine globally
656              RTList<uint>::Iterator       iuiLastStolenKeyGlobally;  ///< Same as iuiLastStolenKey, but engine globally              RTList<uint>::Iterator       iuiLastStolenKeyGlobally;  ///< Same as iuiLastStolenKey, but engine globally
657              RTList<Event>*               pVoiceStealingQueue;   ///< All voice-launching events which had to be postponed due to free voice shortage.              RTList<Event>*               pVoiceStealingQueue;   ///< All voice-launching events which had to be postponed due to free voice shortage.
658              Mutex                        ResetInternalMutex;    ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads).              Mutex                        ResetInternalMutex;    ///< Mutex to protect the ResetInternal function for concurrent usage (e.g. by the lscp and instrument loader threads).
659              int iMaxDiskStreams;              int iMaxDiskStreams;
660    
661                NoteBase* NoteByID(note_id_t id) OVERRIDE {
662                    NoteIterator itNote = GetNotePool()->fromID(id);
663                    if (!itNote) return NULL;
664                    return &*itNote;
665                }
666    
667                /**
668                 * Gets a new @c Note object from the note pool, initializes it
669                 * appropriately, links it with requested parent note (if
670                 * requested), moves it to the appropriate key's list of active
671                 * notes it, and sticks the new note's unique ID to the
672                 * passed @a pNoteOnEvent.
673                 *
674                 * @param pEngineChannel - engine channel on which this event happened
675                 * @param pNoteOnEvent - event which caused this
676                 * @returns new note's unique ID (or zero on error)
677                 */
678                note_id_t LaunchNewNote(LinuxSampler::EngineChannel* pEngineChannel, Event* pNoteOnEvent) OVERRIDE {
679                    EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
680                    Pool< Note<V> >* pNotePool = GetNotePool();
681    
682                    if (pNotePool->poolIsEmpty()) {
683                        dmsg(1,("Engine: Could not launch new note; Note pool empty!\n"));
684                        return 0; // error
685                    }
686    
687                    // create a new note (for new voices to be assigned to)
688                    //NoteIterator itNewNote = pKey->pActiveNotes->allocAppend();
689                    NoteIterator itNewNote = pNotePool->allocAppend();
690                    const note_id_t newNoteID = pNotePool->getID(itNewNote);
691    
692                    // usually the new note (and its subsequent voices) will be
693                    // allocated on the key provided by the event's note number,
694                    // however if this new note is requested not to be a regular
695                    // note, but rather a child note, then this new note will be
696                    // allocated on the parent note's key instead in order to
697                    // release the child note simultaniously with its parent note
698                    itNewNote->hostKey = pNoteOnEvent->Param.Note.Key;
699    
700                    // in case this new note was requested to be a child note,
701                    // then retrieve its parent note and link them with each other
702                    const note_id_t parentNoteID = pNoteOnEvent->Param.Note.ParentNoteID;
703                    if (parentNoteID) {
704                        NoteIterator itParentNote = pNotePool->fromID(parentNoteID);                        
705                        if (itParentNote) {
706                            RTList<note_id_t>::Iterator itChildNoteID = itParentNote->pChildNotes->allocAppend();
707                            if (itChildNoteID) {
708                                // link parent and child note with each other
709                                *itChildNoteID = newNoteID;
710                                itNewNote->parentNoteID = parentNoteID;
711                                itNewNote->hostKey = itParentNote->hostKey;
712                            } else {    
713                                dmsg(1,("Engine: Could not assign new note as child note; Note ID pool empty!\n"));
714                                pNotePool->free(itNewNote);
715                                return 0; // error
716                            }
717                        } else {
718                            // the parent note was apparently released already, so
719                            // free the new note again and inform caller that it
720                            // should drop the event
721                            dmsg(3,("Engine: Could not assign new note as child note; Parent note is gone!\n"));
722                            pNotePool->free(itNewNote);
723                            return 0; // error
724                        }
725                    }
726    
727                    dmsg(2,("Launched new note on host key %d\n", itNewNote->hostKey));
728    
729                    // copy event which caused this note
730                    itNewNote->cause = *pNoteOnEvent;
731                    itNewNote->eventID = pEventPool->getID(pNoteOnEvent);
732    
733                    // move new note to its host key
734                    MidiKey* pKey = &pChannel->pMIDIKeyInfo[itNewNote->hostKey];
735                    itNewNote.moveToEndOf(pKey->pActiveNotes);
736    
737                    // assign unique note ID of this new note to the original note on event
738                    pNoteOnEvent->Param.Note.ID = newNoteID;
739    
740                    return newNoteID; // success
741                }
742    
743              /**              /**
744               * Dispatch and handle all events in this audio fragment for the given               * Dispatch and handle all events in this audio fragment for the given
745               * engine channel.               * engine channel.
# Line 634  namespace LinuxSampler { Line 758  namespace LinuxSampler {
758                  // if a valid real-time instrument script is loaded, pre-process                  // if a valid real-time instrument script is loaded, pre-process
759                  // the event list by running the script now, since the script                  // the event list by running the script now, since the script
760                  // might filter events or add new ones for this cycle                  // might filter events or add new ones for this cycle
761                  if (pChannel->script.bHasValidScript) {                  if (pChannel->pScript) {
762                      // resume any suspended script executions still hanging                      const sched_time_t fragmentEndTime = pEventGenerator->schedTimeAtCurrentFragmentEnd();
763                      // around of previous audio fragment cycles  
764                      for (RTList<ScriptEvent>::Iterator itEvent = pChannel->pScriptEvents->first(),                      // resume suspended script executions been scheduled for
765                          end = pChannel->pScriptEvents->end(); itEvent != end; ++itEvent)                      // this audio fragment cycle (which were suspended in a
766                      {                      // previous audio fragment cycle)
767                          ResumeScriptEvent(pChannel, itEvent); //TODO: implement support for actual suspension time (i.e. passed to a script's wait() function call)                      ProcessSuspendedScriptEvents(pChannel, fragmentEndTime);
                     }  
768    
769                      // spawn new script executions for the new MIDI events of                      // spawn new script executions for the new MIDI events of
770                      // this audio fragment cycle                      // this audio fragment cycle
771                        //
772                        // 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
773                      for (RTList<Event>::Iterator itEvent = pChannel->pEvents->first(),                      for (RTList<Event>::Iterator itEvent = pChannel->pEvents->first(),
774                          end = pChannel->pEvents->end(); itEvent != end; ++itEvent)                          end = pChannel->pEvents->end(); itEvent != end; )
775                      {                      {
776                            //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).
777                            RTList<Event>::Iterator itNext = itEvent;
778                            ++itNext;
779    
780                          switch (itEvent->Type) {                          switch (itEvent->Type) {
781                              case Event::type_note_on:                              case Event::type_note_on:
782                                  if (pChannel->script.handlerNote)                                  if (pChannel->pScript->handlerNote)
783                                      ProcessEventByScript(pChannel, itEvent, pChannel->script.handlerNote);                                      ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerNote);
784                                  break;                                  break;
785                              case Event::type_note_off:                              case Event::type_note_off:
786                                  if (pChannel->script.handlerRelease)                                  if (pChannel->pScript->handlerRelease)
787                                      ProcessEventByScript(pChannel, itEvent, pChannel->script.handlerRelease);                                      ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerRelease);
788                                  break;                                  break;
789                              case Event::type_control_change:                              case Event::type_control_change:
790                              case Event::type_channel_pressure:                              case Event::type_channel_pressure:
791                              case Event::type_pitchbend:                              case Event::type_pitchbend:
792                                  if (pChannel->script.handlerController)                                  if (pChannel->pScript->handlerController)
793                                      ProcessEventByScript(pChannel, itEvent, pChannel->script.handlerController);                                                                  ProcessEventByScript(pChannel, itEvent, pChannel->pScript->handlerController);                            
794                                  break;                                  break;
795                              case Event::type_note_pressure:                              case Event::type_note_pressure:
796                                  //TODO: ...                                  //TODO: ...
797                                  break;                                  break;
798                          }                          }
799    
800                            // see HACK comment above
801                            itEvent = itNext;
802                      }                      }
803    
804                        // this has to be run again, since the newly spawned scripts
805                        // above may have cause suspended scripts that must be
806                        // resumed within this same audio fragment cycle
807                        //
808                        // FIXME: see FIXME comment above
809                        ProcessSuspendedScriptEvents(pChannel, fragmentEndTime);
810                    }
811    
812                    // if there are any delayed events scheduled for the current
813                    // audio fragment cycle, then move and sort them into the main
814                    // event list
815                    if (!pChannel->delayedEvents.queue.isEmpty()) {
816                        dmsg(5,("Engine: There are delayed MIDI events (total queue size: %d) ...\n", pChannel->delayedEvents.queue.size()));
817                        const sched_time_t fragmentEndTime = pEventGenerator->schedTimeAtCurrentFragmentEnd();
818                        RTList<Event>::Iterator itEvent = pChannel->pEvents->first();
819                        while (true) {
820                            RTList<ScheduledEvent>::Iterator itDelayedEventNode =
821                                pEventGenerator->popNextScheduledEvent(
822                                    pChannel->delayedEvents.queue,
823                                    pChannel->delayedEvents.schedulerNodes,
824                                    fragmentEndTime
825                                );
826                            if (!itDelayedEventNode) break;
827                            // get the actual delayed event object and free the used scheduler node
828                            RTList<Event>::Iterator itDelayedEvent = itDelayedEventNode->itEvent;
829                            pChannel->delayedEvents.schedulerNodes.free(itDelayedEventNode);
830                            if (!itDelayedEvent) { // should never happen, but just to be sure ...
831                                dmsg(1,("Engine: Oops, invalid delayed event!\n"));
832                                continue;
833                            }
834                            // skip all events on main event list which have a time
835                            // before (or equal to) the delayed event to be inserted
836                            for (; itEvent && itEvent->FragmentPos() <= itDelayedEvent->FragmentPos();
837                                 ++itEvent);
838                            // now move delayed event from delayedEvents.pList to
839                            // the current position on the main event list
840                            itEvent = itDelayedEvent.moveBefore(itEvent);
841                            dmsg(5,("Engine: Inserted event of type %d into main event list (queue size: %d).\n", itEvent->Type, pChannel->delayedEvents.queue.size()));
842                        }
843                        dmsg(5,("Engine: End of delayed events (total queue size: %d).\n", pChannel->delayedEvents.queue.size()));
844                  }                  }
845    
846                  // now process all events regularly                  // now process all events regularly
# Line 707  namespace LinuxSampler { Line 880  namespace LinuxSampler {
880                  // reset voice stealing for the next engine channel (or next audio fragment)                  // reset voice stealing for the next engine channel (or next audio fragment)
881                  itLastStolenVoice         = VoiceIterator();                  itLastStolenVoice         = VoiceIterator();
882                  itLastStolenVoiceGlobally = VoiceIterator();                  itLastStolenVoiceGlobally = VoiceIterator();
883                    itLastStolenNote          = NoteIterator();
884                    itLastStolenNoteGlobally  = NoteIterator();
885                  iuiLastStolenKey          = RTList<uint>::Iterator();                  iuiLastStolenKey          = RTList<uint>::Iterator();
886                  iuiLastStolenKeyGlobally  = RTList<uint>::Iterator();                  iuiLastStolenKeyGlobally  = RTList<uint>::Iterator();
887                  pLastStolenChannel        = NULL;                  pLastStolenChannel        = NULL;
888              }              }
889    
890                /**
891                 * Run all suspended script execution instances which are scheduled
892                 * to be resumed for the current audio fragment cycle.
893                 *
894                 * @param pChannel - engine channel on which suspended events occurred
895                 */
896                void ProcessSuspendedScriptEvents(AbstractEngineChannel* pChannel, const sched_time_t fragmentEndTime) {
897                    while (true) {
898                        RTList<ScriptEvent>::Iterator itEvent =
899                            pEventGenerator->popNextScheduledScriptEvent(
900                                pChannel->pScript->suspendedEvents,
901                                *pChannel->pScript->pEvents, fragmentEndTime
902                            );
903                        if (!itEvent) break;
904                        ResumeScriptEvent(pChannel, itEvent);
905                    }
906                }
907    
908              /** @brief Call instrument script's event handler for this event.              /** @brief Call instrument script's event handler for this event.
909               *               *
910               * Causes a new execution instance of the currently loaded real-time               * Causes a new execution instance of the currently loaded real-time
911               * instrument script's event handler (callback) to be spawned for               * instrument script's event handler (callback) to be spawned for
912               * the given MIDI event.               * the given MIDI event.
913               *               *
914               * @param pChannel - engine channel on which the MIDI event occured               * @param pChannel - engine channel on which the MIDI event occurred
915               * @param itEvent - MIDI event that causes this new script execution               * @param itEvent - MIDI event that causes this new script execution
916               * @param pEventHandler - script's event handler to be executed               * @param pEventHandler - script's event handler to be executed
917               */               */
918              void ProcessEventByScript(AbstractEngineChannel* pChannel, RTList<Event>::Iterator& itEvent, VMEventHandler* pEventHandler) {              void ProcessEventByScript(AbstractEngineChannel* pChannel, RTList<Event>::Iterator& itEvent, VMEventHandler* pEventHandler) {
919                  RTList<ScriptEvent>::Iterator itScriptEvent =                  const int key = itEvent->Param.Note.Key; // even if this is not a note on/off event, accessing it does not mean any harm
920                      pChannel->pScriptEvents->allocAppend();                  // check if polyphonic data is passed from "note" to "release"
921                    // script event handlers
922                    if (pEventHandler == pChannel->pScript->handlerRelease &&
923                        pChannel->pScript->handlerNote &&
924                        pChannel->pScript->handlerNote->isPolyphonic() &&
925                        pChannel->pScript->handlerRelease->isPolyphonic() &&
926                        !pChannel->pScript->pKeyEvents[key]->isEmpty())
927                    {
928                        // polyphonic variable data is used/passed from "note" to
929                        // "release" script callback, so we have to recycle the
930                        // original "note on" script event(s)
931                        RTList<ScriptEvent>::Iterator it  = pChannel->pScript->pKeyEvents[key]->first();
932                        RTList<ScriptEvent>::Iterator end = pChannel->pScript->pKeyEvents[key]->end();
933                        for (; it != end; ++it) {
934                            ProcessScriptEvent(
935                                pChannel, itEvent, pEventHandler, it
936                            );
937                        }
938                    } else {
939                        // no polyphonic data is used/passed from "note" to
940                        // "release" script callback, so just use a new fresh
941                        // script event object
942                        RTList<ScriptEvent>::Iterator itScriptEvent =
943                            pChannel->pScript->pEvents->allocAppend();
944                        ProcessScriptEvent(
945                            pChannel, itEvent, pEventHandler, itScriptEvent
946                        );
947                    }
948                }
949    
950                  if (!itScriptEvent) return; // no free script event left for execution              /** @brief Spawn new execution instance of an instrument script handler.
951                 *
952                 * Will be called to initiate a new execution of a real-time
953                 * instrument script event right from the start of the script's
954                 * respective handler. If script execution did not complete after
955                 * calling this method, the respective script exeuction is then
956                 * suspended and a call to ResumeScriptEvent() will be used next
957                 * time to continue its execution.
958                 *
959                 * @param pChannel - engine channel this script is running for
960                 * @param itEvent - event which caused execution of this script
961                 *                  event handler
962                 * @param pEventHandler - VM representation of event handler to be
963                 *                        executed
964                 * @param itScriptEvent - script event that shall be processed
965                 */
966                void ProcessScriptEvent(AbstractEngineChannel* pChannel, RTList<Event>::Iterator& itEvent, VMEventHandler* pEventHandler, RTList<ScriptEvent>::Iterator& itScriptEvent) {
967                    if (!itScriptEvent) return; // not a valid script event (i.e. because no free script event was left in the script event pool)
968    
969                  // fill the list of script handlers to be executed by this event                  // fill the list of script handlers to be executed by this event
970                  int i = 0;                  int i = 0;
                 if (pChannel->script.handlerInit)  
                     itScriptEvent->handlers[i++] = pChannel->script.handlerInit;  
971                  itScriptEvent->handlers[i++] = pEventHandler; // actual event handler (i.e. note, controller)                  itScriptEvent->handlers[i++] = pEventHandler; // actual event handler (i.e. note, controller)
972                  itScriptEvent->handlers[i] = NULL; // NULL termination of list                  itScriptEvent->handlers[i] = NULL; // NULL termination of list
973    
# Line 739  namespace LinuxSampler { Line 975  namespace LinuxSampler {
975                  itScriptEvent->cause = *itEvent;                  itScriptEvent->cause = *itEvent;
976                  itScriptEvent->currentHandler = 0;                  itScriptEvent->currentHandler = 0;
977                  itScriptEvent->executionSlices = 0;                  itScriptEvent->executionSlices = 0;
978                    // this is the native representation of the $EVENT_ID script variable
979                    itScriptEvent->id =
980                        (itEvent->Type == Event::type_note_on)
981                            ? ScriptID::fromNoteID( itEvent->Param.Note.ID )
982                            : ScriptID::fromEventID( pEventPool->getID(itEvent) );
983    
984                  // run script handler(s)                  // run script handler(s)
985                  VMExecStatus_t res = pScriptVM->exec(                  VMExecStatus_t res = pScriptVM->exec(
986                      pChannel->script.parserContext, &*itScriptEvent                      pChannel->pScript->parserContext, &*itScriptEvent
987                  );                  );
988    
989                  // in case the script was suspended, keep it on the allocated                  // was the script suspended?
990                  // ScriptEvent list to be continued on the next audio cycle,                  if (res & VM_EXEC_SUSPENDED) { // script was suspended ...
991                  // otherwise if execution has been finished, free it for a new                      // in case the script was suspended, keep it on the allocated
992                  // future script event to be triggered from start                      // ScriptEvent list to be resume at the scheduled time in future,
993                  if (!(res & VM_EXEC_SUSPENDED))                      // additionally insert it into a sorted time queue
994                      pChannel->pScriptEvents->free(itScriptEvent);                      pEventGenerator->scheduleAheadMicroSec(
995                            pChannel->pScript->suspendedEvents, // scheduler queue
996                            *itScriptEvent, // script event
997                            itScriptEvent->cause.FragmentPos(), // current time of script event (basis for its next execution)
998                            itScriptEvent->execCtx->suspensionTimeMicroseconds() // how long shall it be suspended
999                        );
1000                    } else { // script execution has finished without 'suspended' status ...
1001                        // if "polyphonic" variable data is passed from script's
1002                        // "note" event handler to its "release" event handler, then
1003                        // the script event must be kept and recycled for the later
1004                        // occuring "release" script event ...
1005                        if (pEventHandler == pChannel->pScript->handlerNote &&
1006                            pChannel->pScript->handlerRelease &&
1007                            pChannel->pScript->handlerNote->isPolyphonic() &&
1008                            pChannel->pScript->handlerRelease->isPolyphonic())
1009                        {
1010                            const int key = itEvent->Param.Note.Key;
1011                            itScriptEvent.moveToEndOf(pChannel->pScript->pKeyEvents[key & 127]);
1012                        } else {
1013                            // ... otherwise if no polyphonic data is passed and
1014                            // script's execution has finished without suspension
1015                            // status, then free the script event for a new future
1016                            // script event to be triggered from start
1017                            pChannel->pScript->pEvents->free(itScriptEvent);
1018                        }
1019                    }
1020              }              }
1021    
1022              /** @brief Resume execution of instrument script.              /** @brief Resume execution of instrument script.
1023               *               *
1024               * Will be called to resume execution of a real-time instrument               * Will be called to resume execution of a real-time instrument
1025               * script event which has been suspended in a previous audio               * script event which has been suspended previously.
              * fragment cycle.  
1026               *               *
1027               * Script execution might be suspended for various reasons. Usually               * Script execution might be suspended for various reasons. Usually
1028               * a script will be suspended if the script called the built-in               * a script will be suspended if the script called the built-in
# Line 771  namespace LinuxSampler { Line 1036  namespace LinuxSampler {
1036               * @param itScriptEvent - script execution that shall be resumed               * @param itScriptEvent - script execution that shall be resumed
1037               */               */
1038              void ResumeScriptEvent(AbstractEngineChannel* pChannel, RTList<ScriptEvent>::Iterator& itScriptEvent) {              void ResumeScriptEvent(AbstractEngineChannel* pChannel, RTList<ScriptEvent>::Iterator& itScriptEvent) {
1039                    VMEventHandler* handler = itScriptEvent->handlers[itScriptEvent->currentHandler];
1040    
1041                  // run script                  // run script
1042                  VMExecStatus_t res = pScriptVM->exec(                  VMExecStatus_t res = pScriptVM->exec(
1043                      pChannel->script.parserContext, &*itScriptEvent                      pChannel->pScript->parserContext, &*itScriptEvent
1044                  );                  );
1045                  // in case the script was again suspended, keep it on the allocated  
1046                  // ScriptEvent list to be continued on the next audio cycle,                  // was the script suspended?
1047                  // otherwise if execution has been finished, free it for a new                  if (res & VM_EXEC_SUSPENDED) {
1048                  // future script event to be triggered from start                      // in case the script was suspended, keep it on the allocated
1049                  if (!(res & VM_EXEC_SUSPENDED))                      // ScriptEvent list to be resume at the scheduled time in future,
1050                      pChannel->pScriptEvents->free(itScriptEvent);                      // additionally insert it into a sorted time queue
1051                        pEventGenerator->scheduleAheadMicroSec(
1052                            pChannel->pScript->suspendedEvents, // scheduler queue
1053                            *itScriptEvent, // script event
1054                            itScriptEvent->cause.FragmentPos(), // current time of script event (basis for its next execution)
1055                            itScriptEvent->execCtx->suspensionTimeMicroseconds() // how long shall it be suspended
1056                        );
1057                    } else { // script execution has finished without 'suspended' status ...
1058                        // if "polyphonic" variable data is passed from script's
1059                        // "note" event handler to its "release" event handler, then
1060                        // the script event must be kept and recycled for the later
1061                        // occuring "release" script event ...
1062                        if (handler && handler == pChannel->pScript->handlerNote &&
1063                            pChannel->pScript->handlerRelease &&
1064                            pChannel->pScript->handlerNote->isPolyphonic() &&
1065                            pChannel->pScript->handlerRelease->isPolyphonic())
1066                        {
1067                            const int key = itScriptEvent->cause.Param.Note.Key;
1068                            itScriptEvent.moveToEndOf(pChannel->pScript->pKeyEvents[key & 127]);
1069                        } else {
1070                            // ... otherwise if no polyphonic data is passed and
1071                            // script's execution has finished without suspension
1072                            // status, then free the script event for a new future
1073                            // script event to be triggered from start
1074                            pChannel->pScript->pEvents->free(itScriptEvent);
1075                        }
1076                    }
1077              }              }
1078    
1079              /**              /**
# Line 789  namespace LinuxSampler { Line 1082  namespace LinuxSampler {
1082               *  voice stealing and postpone the note-on event until the selected               *  voice stealing and postpone the note-on event until the selected
1083               *  voice actually died.               *  voice actually died.
1084               *               *
1085               *  @param pEngineChannel - engine channel on which this event occured on               *  @param pEngineChannel - engine channel on which this event occurred on
1086               *  @param itNoteOnEvent - key, velocity and time stamp of the event               *  @param itNoteOnEvent - key, velocity and time stamp of the event
1087               *  @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing               *  @returns 0 on success, a value < 0 if no active voice could be picked for voice stealing
1088               */               */
1089              int  StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {              int StealVoice(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
1090                  if (VoiceSpawnsLeft <= 0) {                  if (VoiceSpawnsLeft <= 0) {
1091                      dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));                      dmsg(1,("Max. voice thefts per audio fragment reached (you may raise CONFIG_MAX_VOICES).\n"));
1092                      return -1;                      return -1;
# Line 801  namespace LinuxSampler { Line 1094  namespace LinuxSampler {
1094    
1095                  EngineChannelBase<V, R, I>* pEngineChn = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);                  EngineChannelBase<V, R, I>* pEngineChn = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1096    
1097                  if (!pEventPool->poolIsEmpty()) {                  if (pEventPool->poolIsEmpty()) {
1098                        dmsg(1,("Event pool emtpy!\n"));
1099                        return -1;
1100                    }
1101    
1102                      if(!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &iuiLastStolenKey)) {                  if (!pEngineChn->StealVoice(itNoteOnEvent, &itLastStolenVoice, &itLastStolenNote, &iuiLastStolenKey)) {
1103                          --VoiceSpawnsLeft;                      --VoiceSpawnsLeft;
1104                          return 0;                      return 0;
1105                      }                  }
1106    
1107                      // 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
1108                      // steal oldest voice on the oldest key from any other engine channel                  // steal oldest voice on the oldest key from any other engine channel
1109                      // (the smaller engine channel number, the higher priority)                  // (the smaller engine channel number, the higher priority)
1110                      EngineChannelBase<V, R, I>*  pSelectedChannel;                  EngineChannelBase<V, R, I>*  pSelectedChannel;
1111                      int                       iChannelIndex;                  int                          iChannelIndex;
1112                      VoiceIterator             itSelectedVoice;                  VoiceIterator                itSelectedVoice;
1113    
1114                      // select engine channel                  // select engine channel
1115                      if (pLastStolenChannel) {                  if (pLastStolenChannel) {
1116                          pSelectedChannel = pLastStolenChannel;                      pSelectedChannel = pLastStolenChannel;
1117                          iChannelIndex    = pSelectedChannel->iEngineIndexSelf;                      iChannelIndex    = pSelectedChannel->iEngineIndexSelf;
1118                      } else { // pick the engine channel followed by this engine channel                  } else { // pick the engine channel followed by this engine channel
1119                          iChannelIndex    = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();                      iChannelIndex    = (pEngineChn->iEngineIndexSelf + 1) % engineChannels.size();
1120                          pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);                      pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
1121                      }                  }
1122    
1123                      // if we already stole in this fragment, try to proceed on same key                  // if we already stole in this fragment, try to proceed on same note
1124                      if (this->itLastStolenVoiceGlobally) {                  if (this->itLastStolenVoiceGlobally) {
1125                          itSelectedVoice = this->itLastStolenVoiceGlobally;                      itSelectedVoice = this->itLastStolenVoiceGlobally;
1126                          do {                      do {
1127                              ++itSelectedVoice;                          ++itSelectedVoice;
1128                          } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle                      } while (itSelectedVoice && !itSelectedVoice->IsStealable()); // proceed iterating if voice was created in this fragment cycle
1129                    }
1130                    // did we find a 'stealable' voice?
1131                    if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1132                        // remember which voice we stole, so we can simply proceed on next voice stealing
1133                        this->itLastStolenVoiceGlobally = itSelectedVoice;
1134                        // done
1135                        goto stealable_voice_found;
1136                    }
1137    
1138                    // get (next) oldest note
1139                    if (this->itLastStolenNoteGlobally) {
1140                        for (NoteIterator itNote = ++this->itLastStolenNoteGlobally;
1141                             itNote; ++itNote)
1142                        {
1143                            for (itSelectedVoice = itNote->pActiveVoices->first(); itSelectedVoice; ++itSelectedVoice) {
1144                                // proceed iterating if voice was created in this audio fragment cycle
1145                                if (itSelectedVoice->IsStealable()) {
1146                                    // remember which voice of which note we stole, so we can simply proceed on next voice stealing
1147                                    this->itLastStolenNoteGlobally  = itNote;
1148                                    this->itLastStolenVoiceGlobally = itSelectedVoice;
1149                                    goto stealable_voice_found; // selection succeeded
1150                                }
1151                            }
1152                      }                      }
1153                    }
1154    
1155                      #if CONFIG_DEVMODE                  #if CONFIG_DEVMODE
1156                      EngineChannel* pBegin = pSelectedChannel; // to detect endless loop                  EngineChannel* pBegin = pSelectedChannel; // to detect endless loop
1157                      #endif // CONFIG_DEVMODE                  #endif // CONFIG_DEVMODE
1158    
1159                      // did we find a 'stealable' voice?                  while (true) { // iterate through engine channels                        
1160                      if (itSelectedVoice && itSelectedVoice->IsStealable()) {                      // get (next) oldest key
1161                          // remember which voice we stole, so we can simply proceed on next voice stealing                      RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();
1162                          this->itLastStolenVoiceGlobally = itSelectedVoice;                      this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)
1163                      } else while (true) { // iterate through engine channels                      while (iuiSelectedKey) {
1164                          // get (next) oldest key                          MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];
1165                          RTList<uint>::Iterator iuiSelectedKey = (this->iuiLastStolenKeyGlobally) ? ++this->iuiLastStolenKeyGlobally : pSelectedChannel->pActiveKeys->first();  
1166                          this->iuiLastStolenKeyGlobally = RTList<uint>::Iterator(); // to prevent endless loop (see line above)                          for (NoteIterator itNote = pSelectedKey->pActiveNotes->first(),
1167                          while (iuiSelectedKey) {                               itNotesEnd = pSelectedKey->pActiveNotes->end();
1168                              MidiKey* pSelectedKey = &pSelectedChannel->pMIDIKeyInfo[*iuiSelectedKey];                               itNote != itNotesEnd; ++itNote)
1169                              itSelectedVoice = pSelectedKey->pActiveVoices->first();                          {
1170                                itSelectedVoice = itNote->pActiveVoices->first();
1171                              // proceed iterating if voice was created in this fragment cycle                              // proceed iterating if voice was created in this fragment cycle
1172                              while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;                              while (itSelectedVoice && !itSelectedVoice->IsStealable()) ++itSelectedVoice;
1173                              // found a "stealable" voice ?                              // found a "stealable" voice ?
1174                              if (itSelectedVoice && itSelectedVoice->IsStealable()) {                              if (itSelectedVoice && itSelectedVoice->IsStealable()) {
1175                                  // 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
1176                                  this->iuiLastStolenKeyGlobally  = iuiSelectedKey;                                  this->iuiLastStolenKeyGlobally  = iuiSelectedKey;
1177                                    this->itLastStolenNoteGlobally  = itNote;
1178                                  this->itLastStolenVoiceGlobally = itSelectedVoice;                                  this->itLastStolenVoiceGlobally = itSelectedVoice;
1179                                  this->pLastStolenChannel        = pSelectedChannel;                                  this->pLastStolenChannel        = pSelectedChannel;
1180                                  goto stealable_voice_found; // selection succeeded                                  goto stealable_voice_found; // selection succeeded
1181                              }                              }
                             ++iuiSelectedKey; // get next key on current engine channel  
                         }  
                         // get next 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);  
1182                          }                          }
1183                          #endif // CONFIG_DEVMODE                          ++iuiSelectedKey; // get next key on current engine channel
1184                      }                      }
1185                        // get next engine channel
1186                      // jump point if a 'stealable' voice was found                      iChannelIndex    = (iChannelIndex + 1) % engineChannels.size();
1187                      stealable_voice_found:                      pSelectedChannel = static_cast<EngineChannelBase<V, R, I>*>(engineChannels[iChannelIndex]);
1188    
1189                      #if CONFIG_DEVMODE                      #if CONFIG_DEVMODE
1190                      if (!itSelectedVoice->IsActive()) {                      if (pSelectedChannel == pBegin) {
1191                          dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));                          dmsg(1,("FATAL ERROR: voice stealing endless loop!\n"));
1192                          return -1;                          dmsg(1,("VoiceSpawnsLeft=%d.\n", VoiceSpawnsLeft));
1193                            dmsg(1,("Exiting.\n"));
1194                            exit(-1);
1195                      }                      }
1196                      #endif // CONFIG_DEVMODE                      #endif // CONFIG_DEVMODE
1197                    }
1198    
1199                      // now kill the selected voice                  // jump point if a 'stealable' voice was found
1200                      itSelectedVoice->Kill(itNoteOnEvent);                  stealable_voice_found:
   
                     --VoiceSpawnsLeft;  
1201    
1202                      return 0; // success                  #if CONFIG_DEVMODE
1203                  }                  if (!itSelectedVoice->IsActive()) {
1204                  else {                      dmsg(1,("EngineBase: ERROR, tried to steal a voice which was not active !!!\n"));
                     dmsg(1,("Event pool emtpy!\n"));  
1205                      return -1;                      return -1;
1206                  }                  }
1207                    #endif // CONFIG_DEVMODE
1208    
1209                    // now kill the selected voice
1210                    itSelectedVoice->Kill(itNoteOnEvent);
1211    
1212                    --VoiceSpawnsLeft;
1213    
1214                    return 0; // success
1215              }              }
1216    
1217              void HandleInstrumentChanges() {              void HandleInstrumentChanges() {
# Line 915  namespace LinuxSampler { Line 1233  namespace LinuxSampler {
1233                          dmsg(5,("Engine: instrument change command received\n"));                          dmsg(5,("Engine: instrument change command received\n"));
1234                          cmd.bChangeInstrument = false;                          cmd.bChangeInstrument = false;
1235                          pEngineChannel->pInstrument = cmd.pInstrument;                          pEngineChannel->pInstrument = cmd.pInstrument;
1236                            pEngineChannel->pScript =
1237                                cmd.pScript->bHasValidScript ? cmd.pScript : NULL;
1238                          instrumentChanged = true;                          instrumentChanged = true;
1239    
1240                          pEngineChannel->MarkAllActiveVoicesAsOrphans();                          pEngineChannel->MarkAllActiveVoicesAsOrphans();
1241    
1242                            // the script's "init" event handler is only executed
1243                            // once (when the script is loaded or reloaded)
1244                            if (pEngineChannel->pScript && pEngineChannel->pScript->handlerInit) {
1245                                RTList<ScriptEvent>::Iterator itScriptEvent =
1246                                    pEngineChannel->pScript->pEvents->allocAppend();
1247    
1248                                itScriptEvent->cause.pEngineChannel = pEngineChannel;
1249                                itScriptEvent->handlers[0] = pEngineChannel->pScript->handlerInit;
1250                                itScriptEvent->handlers[1] = NULL;
1251    
1252                                VMExecStatus_t res = pScriptVM->exec(
1253                                    pEngineChannel->pScript->parserContext, &*itScriptEvent
1254                                );
1255    
1256                                pEngineChannel->pScript->pEvents->free(itScriptEvent);
1257                            }
1258                      }                      }
1259                  }                  }
1260    
# Line 968  namespace LinuxSampler { Line 1305  namespace LinuxSampler {
1305                      EngineChannelBase<V, R, I>* pEngineChannel =                      EngineChannelBase<V, R, I>* pEngineChannel =
1306                          static_cast<EngineChannelBase<V, R, I>*>(itVoiceStealEvent->pEngineChannel);;                          static_cast<EngineChannelBase<V, R, I>*>(itVoiceStealEvent->pEngineChannel);;
1307                      if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded                      if (!pEngineChannel->pInstrument) continue; // ignore if no instrument loaded
1308                        
1309                      PoolVoiceIterator itNewVoice =                      PoolVoiceIterator itNewVoice =
1310                          LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);                          LaunchVoice(pEngineChannel, itVoiceStealEvent, itVoiceStealEvent->Param.Note.Layer, itVoiceStealEvent->Param.Note.ReleaseTrigger, false, false);
1311                      if (itNewVoice) {                      if (itNewVoice) {
1312                            // usually there should already be a new Note object
1313                            NoteIterator itNote = GetNotePool()->fromID(itVoiceStealEvent->Param.Note.ID);
1314                            if (!itNote) { // should not happen, but just to be sure ...
1315                                const note_id_t noteID = LaunchNewNote(pEngineChannel, &*itVoiceStealEvent);
1316                                if (!noteID) {
1317                                    dmsg(1,("Engine: Voice stealing failed; No Note object and Note pool empty!\n"));
1318                                    continue;
1319                                }
1320                                itNote = GetNotePool()->fromID(noteID);
1321                            }
1322                            // move voice from whereever it was, to the new note's list of active voices
1323                            itNewVoice = itNewVoice.moveToEndOf(itNote->pActiveVoices);
1324                            // render audio of this new voice for the first time
1325                          itNewVoice->Render(Samples);                          itNewVoice->Render(Samples);
1326                          if (itNewVoice->IsActive()) { // still active                          if (itNewVoice->IsActive()) { // still active
1327                              *(pEngineChannel->pRegionsInUse->allocAppend()) = itNewVoice->GetRegion();                              *(pEngineChannel->pRegionsInUse->allocAppend()) = itNewVoice->GetRegion();
# Line 1008  namespace LinuxSampler { Line 1359  namespace LinuxSampler {
1359                   pChannel->FreeAllInactiveKyes();                   pChannel->FreeAllInactiveKyes();
1360    
1361                  // empty the engine channel's own event lists                  // empty the engine channel's own event lists
1362                  pChannel->ClearEventLists();                  // (only events of the current audio fragment cycle)
1363                    pChannel->ClearEventListsOfCurrentFragment();
1364              }              }
1365    
1366              /**              /**
# Line 1073  namespace LinuxSampler { Line 1425  namespace LinuxSampler {
1425                                  case 0x1d: { // reverb send of note (Roland GS NRPN)                                  case 0x1d: { // reverb send of note (Roland GS NRPN)
1426                                      const uint note = NrpnCtrlLSB;                                      const uint note = NrpnCtrlLSB;
1427                                      const float reverb = float(itControlChangeEvent->Param.CC.Value) / 127.0f;                                      const float reverb = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
1428                                      dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%d).\n", note, reverb));                                      dmsg(4,("Note Reverb Send NRPN received (note=%d,send=%f).\n", note, reverb));
1429                                      if (note < 128)                                      if (note < 128)
1430                                          pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;                                          pChannel->pMIDIKeyInfo[note].ReverbSend = reverb;
1431                                      break;                                      break;
# Line 1081  namespace LinuxSampler { Line 1433  namespace LinuxSampler {
1433                                  case 0x1e: { // chorus send of note (Roland GS NRPN)                                  case 0x1e: { // chorus send of note (Roland GS NRPN)
1434                                      const uint note = NrpnCtrlLSB;                                      const uint note = NrpnCtrlLSB;
1435                                      const float chorus = float(itControlChangeEvent->Param.CC.Value) / 127.0f;                                      const float chorus = float(itControlChangeEvent->Param.CC.Value) / 127.0f;
1436                                      dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%d).\n", note, chorus));                                      dmsg(4,("Note Chorus Send NRPN received (note=%d,send=%f).\n", note, chorus));
1437                                      if (note < 128)                                      if (note < 128)
1438                                          pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;                                          pChannel->pMIDIKeyInfo[note].ChorusSend = chorus;
1439                                      break;                                      break;
# Line 1234  namespace LinuxSampler { Line 1586  namespace LinuxSampler {
1586              /**              /**
1587               *  Assigns and triggers a new voice for the respective MIDI key.               *  Assigns and triggers a new voice for the respective MIDI key.
1588               *               *
1589               *  @param pEngineChannel - engine channel on which this event occured on               *  @param pEngineChannel - engine channel on which this event occurred on
1590               *  @param itNoteOnEvent - key, velocity and time stamp of the event               *  @param itNoteOnEvent - key, velocity and time stamp of the event
1591               */               */
1592              virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {              virtual void ProcessNoteOn(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOnEvent) {
1593                  EngineChannelBase<V, R, I>* pChannel =                  EngineChannelBase<V, R, I>* pChannel =
1594                          static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);                          static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1595    
                 //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;  
   
1596                  const int key = itNoteOnEvent->Param.Note.Key;                  const int key = itNoteOnEvent->Param.Note.Key;
1597                    const int vel = itNoteOnEvent->Param.Note.Velocity;
1598                    if (key < 0 || key > 127) return; // ignore event, key outside allowed key range
1599    
1600                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[key];
1601    
1602                  pChannel->listeners.PreProcessNoteOn(key, vel);                  pChannel->listeners.PreProcessNoteOn(key, vel);
# Line 1276  namespace LinuxSampler { Line 1624  namespace LinuxSampler {
1624                          if (pOtherKey->Active) {                          if (pOtherKey->Active) {
1625                              // get final portamento position of currently active voice                              // get final portamento position of currently active voice
1626                              if (pChannel->PortamentoMode) {                              if (pChannel->PortamentoMode) {
1627                                  VoiceIterator itVoice = pOtherKey->pActiveVoices->last();                                  NoteIterator itNote = pOtherKey->pActiveNotes->last();
1628                                  if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);                                  if (itNote) {
1629                                        VoiceIterator itVoice = itNote->pActiveVoices->last();
1630                                        if (itVoice) itVoice->UpdatePortamentoPos(itNoteOnEventOnKeyList);
1631                                    }
1632                              }                              }
1633                              // kill all voices on the (other) key                              // kill all voices on the (other) key
1634                              VoiceIterator itVoiceToBeKilled = pOtherKey->pActiveVoices->first();                              for (NoteIterator itNote = pOtherKey->pActiveNotes->first(); itNote; ++itNote) {
1635                              VoiceIterator end               = pOtherKey->pActiveVoices->end();                                  VoiceIterator itVoiceToBeKilled = itNote->pActiveVoices->first();
1636                              for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {                                  VoiceIterator end               = itNote->pActiveVoices->end();
1637                                  if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))                                  for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1638                                      itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);                                      if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1639                                            itVoiceToBeKilled->Kill(itNoteOnEventOnKeyList);
1640                                    }
1641                              }                              }
1642                          }                          }
1643                      }                      }
# Line 1295  namespace LinuxSampler { Line 1648  namespace LinuxSampler {
1648                  pChannel->ProcessKeySwitchChange(key);                  pChannel->ProcessKeySwitchChange(key);
1649    
1650                  pKey->KeyPressed = true; // the MIDI key was now pressed down                  pKey->KeyPressed = true; // the MIDI key was now pressed down
1651                    pChannel->KeyDown[key] = true; // just used as built-in %KEY_DOWN script variable
1652                  pKey->Velocity   = itNoteOnEventOnKeyList->Param.Note.Velocity;                  pKey->Velocity   = itNoteOnEventOnKeyList->Param.Note.Velocity;
1653                  pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length                  pKey->NoteOnTime = FrameTime + itNoteOnEventOnKeyList->FragmentPos(); // will be used to calculate note length
1654    
# Line 1345  namespace LinuxSampler { Line 1699  namespace LinuxSampler {
1699               *  sustain pedal will be released or voice turned inactive by itself (e.g.               *  sustain pedal will be released or voice turned inactive by itself (e.g.
1700               *  due to completion of sample playback).               *  due to completion of sample playback).
1701               *               *
1702               *  @param pEngineChannel - engine channel on which this event occured on               *  @param pEngineChannel - engine channel on which this event occurred on
1703               *  @param itNoteOffEvent - key, velocity and time stamp of the event               *  @param itNoteOffEvent - key, velocity and time stamp of the event
1704               */               */
1705              virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {              virtual void ProcessNoteOff(EngineChannel* pEngineChannel, Pool<Event>::Iterator& itNoteOffEvent) {
1706                  EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);                  EngineChannelBase<V, R, I>* pChannel = static_cast<EngineChannelBase<V, R, I>*>(pEngineChannel);
1707    
                 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;  
   
1708                  const int iKey = itNoteOffEvent->Param.Note.Key;                  const int iKey = itNoteOffEvent->Param.Note.Key;
1709                    const int vel  = itNoteOffEvent->Param.Note.Velocity;
1710                    if (iKey < 0 || iKey > 127) return; // ignore event, key outside allowed key range
1711    
1712                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];                  MidiKey* pKey = &pChannel->pMIDIKeyInfo[iKey];
1713    
1714                  pChannel->listeners.PreProcessNoteOff(iKey, vel);                  pChannel->listeners.PreProcessNoteOff(iKey, vel);
# Line 1371  namespace LinuxSampler { Line 1721  namespace LinuxSampler {
1721                  #endif                  #endif
1722    
1723                  pKey->KeyPressed = false; // the MIDI key was now released                  pKey->KeyPressed = false; // the MIDI key was now released
1724                    pChannel->KeyDown[iKey] = false; // just used as built-in %KEY_DOWN script variable
1725    
1726                  // move event to the key's own event list                  // move event to the key's own event list
1727                  RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);                  RTList<Event>::Iterator itNoteOffEventOnKeyList = itNoteOffEvent.moveToEndOf(pKey->pEvents);
# Line 1391  namespace LinuxSampler { Line 1742  namespace LinuxSampler {
1742                                  pChannel->SoloKey = i;                                  pChannel->SoloKey = i;
1743                                  // get final portamento position of currently active voice                                  // get final portamento position of currently active voice
1744                                  if (pChannel->PortamentoMode) {                                  if (pChannel->PortamentoMode) {
1745                                      VoiceIterator itVoice = pKey->pActiveVoices->first();                                      NoteIterator itNote = pKey->pActiveNotes->first();
1746                                        VoiceIterator itVoice = itNote->pActiveVoices->first();
1747                                      if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);                                      if (itVoice) itVoice->UpdatePortamentoPos(itNoteOffEventOnKeyList);
1748                                  }                                  }
1749                                  // create a pseudo note on event                                  // create a pseudo note on event
# Line 1403  namespace LinuxSampler { Line 1755  namespace LinuxSampler {
1755                                      itPseudoNoteOnEvent->Type                = Event::type_note_on;                                      itPseudoNoteOnEvent->Type                = Event::type_note_on;
1756                                      itPseudoNoteOnEvent->Param.Note.Key      = i;                                      itPseudoNoteOnEvent->Param.Note.Key      = i;
1757                                      itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;                                      itPseudoNoteOnEvent->Param.Note.Velocity = pOtherKey->Velocity;
1758                                      // allocate and trigger new voice(s) for the other key                                      // assign a new note to this note-on event
1759                                      TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);                                      if (LaunchNewNote(pChannel, &*itPseudoNoteOnEvent)) {
1760                                            // allocate and trigger new voice(s) for the other key
1761                                            TriggerNewVoices(pChannel, itPseudoNoteOnEvent, false);
1762                                        }
1763                                      // if neither a voice was spawned or postponed then remove note on event from key again                                      // if neither a voice was spawned or postponed then remove note on event from key again
1764                                      if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)                                      if (!pOtherKey->Active && !pOtherKey->VoiceTheftsQueued)
1765                                          pOtherKey->pEvents->free(itPseudoNoteOnEvent);                                          pOtherKey->pEvents->free(itPseudoNoteOnEvent);
# Line 1417  namespace LinuxSampler { Line 1772  namespace LinuxSampler {
1772                      if (bOtherKeysPressed) {                      if (bOtherKeysPressed) {
1773                          if (pKey->Active) { // kill all voices on this key                          if (pKey->Active) { // kill all voices on this key
1774                              bShouldRelease = false; // no need to release, as we kill it here                              bShouldRelease = false; // no need to release, as we kill it here
1775                              VoiceIterator itVoiceToBeKilled = pKey->pActiveVoices->first();                              for (NoteIterator itNote = pKey->pActiveNotes->first(); itNote; ++itNote) {
1776                              VoiceIterator end               = pKey->pActiveVoices->end();                                  VoiceIterator itVoiceToBeKilled = itNote->pActiveVoices->first();
1777                              for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {                                  VoiceIterator end               = itNote->pActiveVoices->end();
1778                                  if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))                                  for (; itVoiceToBeKilled != end; ++itVoiceToBeKilled) {
1779                                      itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);                                      if (!(itVoiceToBeKilled->Type & Voice::type_release_trigger))
1780                                            itVoiceToBeKilled->Kill(itNoteOffEventOnKeyList);
1781                                    }
1782                              }                              }
1783                          }                          }
1784                      } else pChannel->PortamentoPos = -1.0f;                      } else pChannel->PortamentoPos = -1.0f;
# Line 1433  namespace LinuxSampler { Line 1790  namespace LinuxSampler {
1790    
1791                      // spawn release triggered voice(s) if needed                      // spawn release triggered voice(s) if needed
1792                      if (pKey->ReleaseTrigger && pChannel->pInstrument) {                      if (pKey->ReleaseTrigger && pChannel->pInstrument) {
1793                          TriggerReleaseVoices(pChannel, itNoteOffEventOnKeyList);                          // assign a new note to this release event
1794                            if (LaunchNewNote(pChannel, &*itNoteOffEventOnKeyList)) {
1795                                // allocate and trigger new release voice(s)
1796                                TriggerReleaseVoices(pChannel, itNoteOffEventOnKeyList);
1797                            }
1798                          pKey->ReleaseTrigger = false;                          pKey->ReleaseTrigger = false;
1799                      }                      }
1800                  }                  }
# Line 1462  namespace LinuxSampler { Line 1823  namespace LinuxSampler {
1823                  pVoiceStealingQueue->clear();                  pVoiceStealingQueue->clear();
1824                  itLastStolenVoice          = VoiceIterator();                  itLastStolenVoice          = VoiceIterator();
1825                  itLastStolenVoiceGlobally  = VoiceIterator();                  itLastStolenVoiceGlobally  = VoiceIterator();
1826                    itLastStolenNote           = NoteIterator();
1827                    itLastStolenNoteGlobally   = NoteIterator();
1828                  iuiLastStolenKey           = RTList<uint>::Iterator();                  iuiLastStolenKey           = RTList<uint>::Iterator();
1829                  iuiLastStolenKeyGlobally   = RTList<uint>::Iterator();                  iuiLastStolenKeyGlobally   = RTList<uint>::Iterator();
1830                  pLastStolenChannel         = NULL;                  pLastStolenChannel         = NULL;
1831    
1832                    // reset all notes
1833                    pNotePool->clear();
1834                    for (NoteIterator itNote = pNotePool->allocAppend(); itNote;
1835                         itNote = pNotePool->allocAppend())
1836                    {
1837                        itNote->reset();
1838                    }
1839                    pNotePool->clear();
1840    
1841                  // reset all voices                  // reset all voices
1842                    pVoicePool->clear();
1843                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {                  for (VoiceIterator iterVoice = pVoicePool->allocAppend(); iterVoice == pVoicePool->last(); iterVoice = pVoicePool->allocAppend()) {
1844                      iterVoice->Reset();                      iterVoice->Reset();
1845                  }                  }
1846                  pVoicePool->clear();                  pVoicePool->clear();
1847    
1848                    // reset all engine channels
1849                    for (int i = 0; i < engineChannels.size(); i++) {
1850                        AbstractEngineChannel* pEngineChannel =
1851                            static_cast<AbstractEngineChannel*>(engineChannels[i]);
1852                        pEngineChannel->ResetInternal(false/*don't reset engine*/);
1853                    }
1854    
1855                  // reset disk thread                  // reset disk thread
1856                  if (pDiskThread) pDiskThread->Reset();                  if (pDiskThread) pDiskThread->Reset();
1857    
# Line 1500  namespace LinuxSampler { Line 1880  namespace LinuxSampler {
1880               *  called by the ProcessNoteOn() method and by the voices itself               *  called by the ProcessNoteOn() method and by the voices itself
1881               *  (e.g. to spawn further voices on the same key for layered sounds).               *  (e.g. to spawn further voices on the same key for layered sounds).
1882               *               *
1883               *  @param pEngineChannel      - engine channel on which this event occured on               *  @param pEngineChannel      - engine channel on which this event occurred on
1884               *  @param itNoteOnEvent       - key, velocity and time stamp of the event               *  @param itNoteOnEvent       - key, velocity and time stamp of the event
1885               *  @param iLayer              - layer index for the new voice (optional - only               *  @param iLayer              - layer index for the new voice (optional - only
1886               *                               in case of layered sounds of course)               *                               in case of layered sounds of course)
# Line 1543  namespace LinuxSampler { Line 1923  namespace LinuxSampler {
1923                      // launch the new voice                      // launch the new voice
1924                      if (itNewVoice->Trigger(pChannel, itNoteOnEvent, pChannel->Pitch, pRegion, VoiceType, iKeyGroup) < 0) {                      if (itNewVoice->Trigger(pChannel, itNoteOnEvent, pChannel->Pitch, pRegion, VoiceType, iKeyGroup) < 0) {
1925                          dmsg(4,("Voice not triggered\n"));                          dmsg(4,("Voice not triggered\n"));
1926                          pKey->pActiveVoices->free(itNewVoice);                          GetVoicePool()->free(itNewVoice);
1927                      }                      }
1928                      else { // on success                      else { // on success
1929                          --VoiceSpawnsLeft;                          --VoiceSpawnsLeft;
# Line 1592  namespace LinuxSampler { Line 1972  namespace LinuxSampler {
1972              }              }
1973    
1974          private:          private:
1975                Pool< Note<V> >* pNotePool;
1976                Pool<note_id_t> noteIDPool;
1977              Pool<V>*    pVoicePool;            ///< Contains all voices that can be activated.              Pool<V>*    pVoicePool;            ///< Contains all voices that can be activated.
1978              Pool<RR*>   SuspendedRegions;              Pool<RR*>   SuspendedRegions;
1979              Mutex       SuspendedRegionsMutex;              Mutex       SuspendedRegionsMutex;
Legend:
Removed from v.2596  
changed lines
  Added in v.2884
  ViewVC Help
Powered by ViewVC